package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.github.pagehelper.Page;
import com.wicket.okrapp.base.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.common.*;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.biz.service.dto.common.ExecuteCycleStageDto;
import com.wicket.okrapp.biz.service.dto.common.FieldDataDto;
import com.wicket.okrapp.biz.service.dto.common.TargetBelongCycleDto;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.AddPlanFinanceMqQueueComReqDto;
import com.wicket.okrapp.biz.service.dto.req.AddPlanTargetMqQueueComReqDto;
import com.wicket.okrapp.biz.service.dto.req.QueryPlanFinanceMqQueueListComReqDto;
import com.wicket.okrapp.biz.service.dto.req.QueryPlanTargetMqQueueListComReqDto;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.biz.service.dto.res.AddPlanFinanceMqQueueComRespDto;
import com.wicket.okrapp.biz.service.dto.res.AddPlanTargetMqQueueComRespDto;
import com.wicket.okrapp.biz.service.dto.res.QueryPlanFinanceMqQueueListComRespDto;
import com.wicket.okrapp.biz.service.dto.res.QueryPlanTargetMqQueueListComRespDto;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcalc.integration.dto.*;
import com.wicket.okrcalc.integration.dto.SumOfMultipleNumDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrframework.integration.dto.*;
import com.wicket.okrframework.integration.dto.BeginMemberDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.BusinessAtomService;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrcomponent.integration.dto.QueryRedisBusinessDataSetDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryRedisBusinessDataSetDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.RefreshSegQueryRedisRecordComRespDto;
import com.wicket.okrcomponent.integration.dto.RefreshSegQueryRedisRecordComReqDto;
import com.wicket.okrcomponent.integration.dto.DeleteRedisBusinessDataComRespDto;
import com.wicket.okrcomponent.integration.dto.DeleteRedisBusinessDataComReqDto;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.biz.service.nb.NbEvaCalc;
import com.wicket.okrcomponent.integration.FwCompBusinessAtomClient;
import com.wicket.okrcomponent.integration.FwCompEvaCalcClient;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.base.service.MOmsTargetCyclePlanSetService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCyclePlanSet;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrcomponent.integration.dto.CheckTimeScopeSearchComRespDto;
import com.wicket.okrcomponent.integration.dto.CheckTimeScopeSearchComReqDto;
import com.wicket.okrcomponent.integration.FwCompDivineDataClient;
import com.wicket.okrapp.base.service.MOmsTspeCycleStageDataService;
import com.wicket.okrapp.dal.po.mbg.OmsTspeCycleStageData;
import com.wicket.okrapp.dal.po.mbg.OmsTargetAttributionCycle;
import com.wicket.okrapp.biz.service.ExecuteCycleService;
import com.wicket.okrcomponent.integration.dto.CalculateContentAmountComRespDto;
import com.wicket.okrcomponent.integration.dto.CalculateContentAmountComReqDto;
import com.wicket.okrcomponent.integration.FwCompStatisticalDataClient;
import com.wicket.okrapp.biz.service.DashboardTargetContentService;
import com.wicket.okrapp.base.service.MOmsTargetCategoryService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategory;

import java.util.ArrayList;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComRespDto;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcalc.integration.FwCalcEvaCalcClient;
import com.wicket.okrcalc.integration.FwCalcTargetCalcClient;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrcalc.integration.FwCalcInterfaceModeClient;
import com.wicket.okrcalc.integration.FwCalcStandardDataClient;
import com.wicket.okrapp.biz.service.CycleStageDataService;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrapp.biz.service.FinanceService;
import com.wicket.okrapp.base.service.MOmsTargetObjectivePlanExtendService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjectivePlanExtend;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.biz.service.TargetContComService;
import com.wicket.okrcomponent.integration.dto.BatchDeleteDocRelOrDocComRespDto;
import com.wicket.okrcomponent.integration.dto.BatchDeleteDocRelOrDocComReqDto;
import com.wicket.okrcomponent.integration.FwCompUnstructuredDataClient;
import com.wicket.okrapp.base.service.MOmsBizAppHypertextContentService;
import com.wicket.okrapp.dal.po.mbg.OmsBizAppHypertextContent;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrframework.integration.dto.BatchQueryUserinfoByMemberComRespDto;
import com.wicket.okrframework.integration.dto.BatchQueryUserinfoByMemberComReqDto;
import com.wicket.okrapp.biz.service.SmallCircleCommonService;
import com.wicket.okrframework.integration.FwBaseDashboardOrgClient;
import com.wicket.okrapp.base.service.MOmsVirtualOrgMemberDeptService;
import com.wicket.okrapp.dal.po.mbg.OmsVirtualOrgMemberDept;
import com.wicket.okrapp.base.service.dto.common.VirtualOrgMemberDeptDto;
import com.wicket.okrcomponent.integration.dto.ImplementManyFieldsDataSetDuplicateRemovalComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementManyFieldsDataSetDuplicateRemovalComReqDto;
import com.wicket.okrcomponent.integration.dto.DataSetDuplicateRemovalDto;
import com.wicket.okrcomponent.integration.dto.ImplementDataSubtractOneComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementDataSubtractOneComReqDto;
import com.wicket.okrapp.dal.po.mbg.OmsTask;
import com.wicket.okrapp.biz.service.VirtualOrgService;
import com.wicket.okrframework.integration.FwBaseOrgClient;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrcalc.integration.FwCalcDashboradStandardDataClient;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrcomponent.integration.dto.ImplementLookAncestorNodeCodeComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementLookAncestorNodeCodeComReqDto;
import com.wicket.okrapp.dal.po.mbg.OmsExecuteCycleStage;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrcomponent.integration.dto.AddMessageQueueDataBusComRespDto;
import com.wicket.okrcomponent.integration.dto.AddMessageQueueDataBusComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryMessageQueueDataListComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryMessageQueueDataListComReqDto;


/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class EvaCalcServiceImpl
  implements com.wicket.okrapp.biz.service.EvaCalcService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private BusinessAtomService businessAtomService;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private NbEvaCalc nbEvaCalc;
@Resource
  private FwCompBusinessAtomClient fwCompBusinessAtomClient;
@Resource
  private FwCompEvaCalcClient fwCompEvaCalcClient;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsTargetCyclePlanSetService mOmsTargetCyclePlanSetService;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
@Resource
  private ExecuteCycleService executeCycleService;
@Resource
  private FwCompStatisticalDataClient fwCompStatisticalDataClient;
@Resource
  private DashboardTargetContentService dashboardTargetContentService;
@Resource
  private MOmsTargetCategoryService mOmsTargetCategoryService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private FwCalcEvaCalcClient fwCalcEvaCalcClient;
@Resource
  private FwCalcTargetCalcClient fwCalcTargetCalcClient;
@Resource
  private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
@Resource
  private FwCalcInterfaceModeClient fwCalcInterfaceModeClient;
@Resource
  private FwCalcStandardDataClient fwCalcStandardDataClient;
@Resource
  private CycleStageDataService cycleStageDataService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private FinanceService financeService;
@Resource
  private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
@Resource
  private TargetContComService targetContComService;
@Resource
  private FwCompUnstructuredDataClient fwCompUnstructuredDataClient;
@Resource
  private MOmsBizAppHypertextContentService mOmsBizAppHypertextContentService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private SmallCircleCommonService smallCircleCommonService;
@Resource
  private FwBaseDashboardOrgClient fwBaseDashboardOrgClient;
@Resource
  private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private FwBaseOrgClient fwBaseOrgClient;
@Resource
  private FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  private FwCalcDashboradStandardDataClient fwCalcDashboradStandardDataClient;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private TargetContentService targetContentService;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
/**
   * D3分段查执行周期阶段(公共)[9678]
   * gen by moon at 5/31/2024, 2:46:06 AM
   */
  @Trace(operationName = "D3分段查执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSegQueryExecuteCycleComRespDto implementSegQueryExecuteCycleCom(ImplementSegQueryExecuteCycleComReqDto reqDto){
    
      
      ImplementGeneralSubsectionQueryBusinessDataSetComRespDto implementGeneralSubsectionQueryBusinessDataSetComRespDto_1 =null;
//步骤0: D3通用分段查询业务数据对象(业务原子) - implementGeneralSubsectionQueryBusinessDataSetCom
     ImplementGeneralSubsectionQueryBusinessDataSetComRespDto implementGeneralSubsectionQueryBusinessDataSetComRespDto = null;
    ImplementGeneralSubsectionQueryBusinessDataSetComReqDto implementGeneralSubsectionQueryBusinessDataSetComReqDto=new ImplementGeneralSubsectionQueryBusinessDataSetComReqDto();
  implementGeneralSubsectionQueryBusinessDataSetComReqDto.setBusinessDataSetPrimaryKeyName("executeCycleStageId");//CUSTOM_CONVENTION//sourceId:1826359_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldName1("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1826413_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldName2("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1826416_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomField1("relateContentTypeCode");//CUSTOM_CONVENTION//sourceId:1826342_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomField2("relateContentId");//CUSTOM_CONVENTION//sourceId:1826344_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomField3("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1826346_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomField4("subjectLifeCycle");//CUSTOM_CONVENTION//sourceId:1826851_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField1("executeCycleStageId");//CUSTOM_CONVENTION//sourceId:1826363_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField2("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1826364_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField3("lastExecuteCycleStageId");//CUSTOM_CONVENTION//sourceId:1826365_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField4("cycleId");//CUSTOM_CONVENTION//sourceId:1826366_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField5("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1826367_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField6("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1826368_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField7("cycleTypeCode");//CUSTOM_CONVENTION//sourceId:1826369_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField8("cycleTypeInstanceCode");//CUSTOM_CONVENTION//sourceId:1826370_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField9("isLastCycle");//CUSTOM_CONVENTION//sourceId:1826371_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField10("orderNumber");//CUSTOM_CONVENTION//sourceId:1826372_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setCustomField11("nextCyclePeriod");//CUSTOM_CONVENTION//sourceId:1826373_1
if(reqDto!=null){
      implementGeneralSubsectionQueryBusinessDataSetComReqDto.setBusinessDataSetTableName(reqDto.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1826360_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setDatasNum(reqDto.getDatasNum());//SimpleFieldAssign//sourceId:1826340_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setOrderFieldName(reqDto.getOrderFieldName());//SimpleFieldAssign//sourceId:1826361_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setOrderRule(reqDto.getOrderRule());//SimpleFieldAssign//sourceId:1826362_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setLastDataObjectId(reqDto.getLastDataObjectId());//SimpleFieldAssign//sourceId:1826341_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldValue1(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1826414_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldRule1(reqDto.getComTimeFieldRule1());//SimpleFieldAssign//sourceId:1826415_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldValue2(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1826417_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setComTimeFieldRule2(reqDto.getComTimeFieldRule2());//SimpleFieldAssign//sourceId:1826418_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1826343_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomFieldValue2(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1826345_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomFieldValue3(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1826347_1
implementGeneralSubsectionQueryBusinessDataSetComReqDto.setRefCustomFieldValue4(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1826852_1
    }
  
    /*D3通用分段查询业务数据对象(业务原子)[9400]   */
    Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getBusinessDataSetTableName(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-数据对象表名不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getDatasNum(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-数据条数不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getOrderFieldName(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-排序字段名不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getOrderRule(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-排序规则不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getBusinessDataSetPrimaryKeyName(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-数据对象主键名不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getComTimeFieldName1(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-时间字段名1不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getRefCustomField1(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-入参自定义字段1不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getRefCustomField2(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-入参自定义字段2不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getRefCustomField3(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-入参自定义字段3不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getRefCustomField4(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-入参自定义字段4不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField1(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段1不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField2(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段2不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField3(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段3不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField4(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段4不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField5(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段5不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField6(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段6不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField7(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段7不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField8(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段8不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField9(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段9不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField10(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段10不能为空",false);
Assert.isNull(implementGeneralSubsectionQueryBusinessDataSetComReqDto.getCustomField11(),"D3分段查执行周期阶段(公共)-D3通用分段查询业务数据对象(业务原子)-自定义字段11不能为空",false);
      implementGeneralSubsectionQueryBusinessDataSetComRespDto = businessAtomService.implementGeneralSubsectionQueryBusinessDataSetCom(implementGeneralSubsectionQueryBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      implementGeneralSubsectionQueryBusinessDataSetComRespDto_1 = implementGeneralSubsectionQueryBusinessDataSetComRespDto;
    
ImplementSegQueryExecuteCycleComRespDto retData = new ImplementSegQueryExecuteCycleComRespDto();
  if(implementGeneralSubsectionQueryBusinessDataSetComRespDto_1!=null){
      retData.setExecuteCycleStageList(//objList-to-objLists
        implementGeneralSubsectionQueryBusinessDataSetComRespDto_1.getBusinessDataSetList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCustomField1());//SimpleFieldAssign//sourceId:367224_2
elm.setLastExecuteCycleStageId(item.getCustomField3());//SimpleFieldAssign//sourceId:367226_2
elm.setEvaObjTargetCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:367225_2
elm.setCycleId(item.getCustomField4());//SimpleFieldAssign//sourceId:367227_2
elm.setCycleStartTime(item.getCustomField5()!=null?CommonFunctionHelper.str2Date(item.getCustomField5()):null);//SimpleFieldAssign//sourceId:367228_2
elm.setCycleEndTime(item.getCustomField6()!=null?CommonFunctionHelper.str2Date(item.getCustomField6()):null);//SimpleFieldAssign//sourceId:367229_2
elm.setCycleTypeCode(item.getCustomField7());//SimpleFieldAssign//sourceId:367230_2
elm.setCycleTypeInstanceCode(item.getCustomField8());//SimpleFieldAssign//sourceId:367231_2
elm.setIsLastCycle(item.getCustomField9());//SimpleFieldAssign//sourceId:367232_2
elm.setOrderNumber(Long.valueOf(item.getCustomField10()));//SimpleFieldAssign//sourceId:367233_2
elm.setNextCyclePeriod(item.getCustomField11());//SimpleFieldAssign//sourceId:367234_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1826432_1
    }
  

  
  
return retData;
  }
/**
   * D3分段刷全模板目标归属周期(公共)[9677]
   * gen by moon at 5/30/2024, 7:27:16 PM
   */
  @Trace(operationName = "D3分段刷全模板目标归属周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSegBrushFullTempTargetOwnershipCycleComRespDto implementSegBrushFullTempTargetOwnershipCycleCom(ImplementSegBrushFullTempTargetOwnershipCycleComReqDto reqDto){
    
      
      //virtualUsage M3约定业务数据对象表名  69345
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setBusinessDataSetTableName("oms_execute_cycle_stage");//CUSTOM_CONVENTION//sourceId:1826836_1_69345
receptionServiceReq.setRedisDataObjectCatalogue("分段查询临时记录");//sourceId:1826837_1_69345
receptionServiceReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1826846_1_69345
  
    /*M3约定业务数据对象表名[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBusinessDataSetTableName(),"D3分段刷全模板目标归属周期(公共)-M3约定业务数据对象表名-业务数据对象表名不能为空",false);
Assert.isNull(receptionServiceReq.getRedisDataObjectCatalogue(),"D3分段刷全模板目标归属周期(公共)-M3约定业务数据对象表名-Redis数据对象目录不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3分段刷全模板目标归属周期(公共)-M3约定业务数据对象表名-关联目标内容类型编码不能为空",false);
      receptionServiceRes = nbEvaCalc.implementFiveReceivingField(receptionServiceReq);
      
      
      
//virtualUsage M3执行死循环(特殊方法）  69342
      //ModelCode: endlessLoop
      // TODO: 2024/5/31
      while(true) {


//virtualUsage D2查Redis中上一批次数据集最后一条记录（业务原子）  69343
          QueryRedisBusinessDataSetDetailComRespDto queryRedisBusinessDataSetDetailComRespDto = null;
          QueryRedisBusinessDataSetDetailComReqDto queryRedisBusinessDataSetDetailComReqDto = new QueryRedisBusinessDataSetDetailComReqDto();
          if (receptionServiceRes != null) {
              queryRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1826840_1_69343
              queryRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1826842_1_69343
          }
          if (reqDto != null) {
              queryRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1826841_1_69343
          }

          /*D2查Redis中上一批次数据集最后一条记录（业务原子）[8411]   */
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D3分段刷全模板目标归属周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-业务数据对象不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D3分段刷全模板目标归属周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-Redis数据对象目录不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D3分段刷全模板目标归属周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-数据对象批次标识不能为空", false);
          queryRedisBusinessDataSetDetailComRespDto = fwCompBusinessAtomClient.queryRedisBusinessDataSetDetailCom(queryRedisBusinessDataSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3分段查执行周期阶段(公共)  69344
          ImplementSegQueryExecuteCycleComRespDto implementSegQueryExecuteCycleComRespDto = null;
          if (queryRedisBusinessDataSetDetailComRespDto != null) {
              ImplementSegQueryExecuteCycleComReqDto implementSegQueryExecuteCycleComReqDto = new ImplementSegQueryExecuteCycleComReqDto();
              implementSegQueryExecuteCycleComReqDto.setDatasNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1826434_1_69344
              implementSegQueryExecuteCycleComReqDto.setOrderFieldName("orderNumber");//CUSTOM_CONVENTION//sourceId:1826435_1_69344
              implementSegQueryExecuteCycleComReqDto.setOrderRule("FROM_LARGE_TO_SMALL");//sourceId:1826436_1_69344
              implementSegQueryExecuteCycleComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//CUSTOM_CONVENTION//sourceId:1826855_1_69344
              if (receptionServiceRes != null) {
                  implementSegQueryExecuteCycleComReqDto.setBusinessDataSetTableName(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1826433_1_69344
                  implementSegQueryExecuteCycleComReqDto.setRelateContentTypeCode(receptionServiceRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1826442_1_69344
              }
              if (queryRedisBusinessDataSetDetailComRespDto != null) {
                  implementSegQueryExecuteCycleComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1826437_1_69344
              }
              if (reqDto != null) {
                  implementSegQueryExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1826444_1_69344
              }

              /*D3分段查执行周期阶段(公共)[9678]   */
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getBusinessDataSetTableName(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-业务数据对象表名不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getDatasNum(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-数据条数不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getOrderFieldName(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-排序字段名不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getOrderRule(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-排序规则不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getRelateContentTypeCode(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getEvaluationTemplateId(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-评价模板ID不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getSubjectLifeCycle(), "D3分段刷全模板目标归属周期(公共)-D3分段查执行周期阶段(公共)-主体生命周期不能为空", false);
              implementSegQueryExecuteCycleComRespDto = implementSegQueryExecuteCycleCom(implementSegQueryExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;


          }
          if ((implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().size() > 0)) {
              //if(D3分段查执行周期阶段(公共).执行周期阶段列表数据集条数 大于 0)  69346

              RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordComRespDto = null;
              if (implementSegQueryExecuteCycleComRespDto != null && queryRedisBusinessDataSetDetailComRespDto != null) {
                  RefreshSegQueryRedisRecordComReqDto refreshSegQueryRedisRecordComReqDto = new RefreshSegQueryRedisRecordComReqDto();
                  refreshSegQueryRedisRecordComReqDto.setBusinessDataSetPrimaryKeyName("executeCycleStageId");//CUSTOM_CONVENTION//sourceId:1827234_1_69361
                  if (implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList())) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataSetList(implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().stream().map(item -> String.valueOf(item.getExecuteCycleStageId()))
                              .collect(Collectors.toList()));/*list-to-strings*///sourceId:1827229_1_69361
                  }
                  if (receptionServiceRes != null) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827230_1_69361
                      refreshSegQueryRedisRecordComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827231_1_69361
                  }
                  if (reqDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827232_1_69361
                  }
                  if (queryRedisBusinessDataSetDetailComRespDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1827233_1_69361
                  }

                  /*D2更新分段查询Redis记录(公共)[9679]   */
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataObject(), "D3分段刷全模板目标归属周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getRedisDataObjectCatalogue(), "D3分段刷全模板目标归属周期(公共)-D2更新分段查询Redis记录(公共)-Redis数据对象目录不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getDataObjectBatchCode(), "D3分段刷全模板目标归属周期(公共)-D2更新分段查询Redis记录(公共)-数据对象批次标识不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataSetPrimaryKeyName(), "D3分段刷全模板目标归属周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象主键名不能为空", false);
                  refreshSegQueryRedisRecordComRespDto = fwCompEvaCalcClient.refreshSegQueryRedisRecordCom(refreshSegQueryRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


              }
//ModelCode: circulationCollections
              for (ExecuteCycleStageDto circulationCollectionsRes : implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList()) {

                  AnalysisParentSubMidCycleTypeComRespDto analysisParentSubMidCycleTypeComRespDto = null;
                  AnalysisParentSubMidCycleTypeComReqDto analysisParentSubMidCycleTypeComReqDto = new AnalysisParentSubMidCycleTypeComReqDto();


                  /*D3分析目标执行周期当前牌父子中周期类型(公共)[8591]   */
//                  Assert.isNull(analysisParentSubMidCycleTypeComReqDto.getPeriodicModeTypeCode(), "D3分段刷全模板目标归属周期(公共)-D3分析目标执行周期当前牌父子中周期类型(公共)-周期模式类型编码不能为空", false);
//                  Assert.isNull(analysisParentSubMidCycleTypeComReqDto.getEvaObjTargetCycleId(), "D3分段刷全模板目标归属周期(公共)-D3分析目标执行周期当前牌父子中周期类型(公共)-被评对象目标周期ID不能为空", false);
//                  Assert.isNull(analysisParentSubMidCycleTypeComReqDto.getCycleTypeCode(), "D3分段刷全模板目标归属周期(公共)-D3分析目标执行周期当前牌父子中周期类型(公共)-周期类型标识不能为空", false);
//                  Assert.isNull(analysisParentSubMidCycleTypeComReqDto.getEvaluationTemplateId(), "D3分段刷全模板目标归属周期(公共)-D3分析目标执行周期当前牌父子中周期类型(公共)-冗余评价模板ID不能为空", false);
//                  analysisParentSubMidCycleTypeComRespDto = targetCalcService.analysisParentSubMidCycleTypeCom(analysisParentSubMidCycleTypeComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: circulationEnd
              }

          } else if ((implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().size() == 0)) {
              //elseif(D3分段查执行周期阶段(周期排序从大到小).执行周期阶段列表数据集条数 等于 0)  69351

              DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
              DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto = new DeleteRedisBusinessDataComReqDto();
              deleteRedisBusinessDataComReqDto.setIsDataList("FALSE");//sourceId:1826335_1_69352
              if (receptionServiceRes != null) {
                  deleteRedisBusinessDataComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1826332_1_69352
                  deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1826336_1_69352
              }
              if (reqDto != null) {
                  deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1826334_1_69352
              }

              /*D2-删除redis业务数据对象(公共)[8397]   */
              Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(), "D3分段刷全模板目标归属周期(公共)-D2-删除redis业务数据对象(公共)-业务数据对象不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(), "D3分段刷全模板目标归属周期(公共)-D2-删除redis业务数据对象(公共)-Redis数据对象目录不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getDataObjectBatchCode(), "D3分段刷全模板目标归属周期(公共)-D2-删除redis业务数据对象(公共)-数据对象批次标识不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(), "D3分段刷全模板目标归属周期(公共)-D2-删除redis业务数据对象(公共)-是否是数据集对象不能为空", false);
              deleteRedisBusinessDataComRespDto = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: end
              // TODO: 2024/5/31
              break;


          }
      }
ImplementSegBrushFullTempTargetOwnershipCycleComRespDto retData = new ImplementSegBrushFullTempTargetOwnershipCycleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3分段全量周期刷评价模板标准数据(公共)[9680]
   * gen by moon at 5/30/2024, 11:05:39 PM
   */
  @Trace(operationName = "D3分段全量周期刷评价模板标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSegAllCycleBrushEvaTempStandardDataComRespDto implementSegAllCycleBrushEvaTempStandardDataCom(ImplementSegAllCycleBrushEvaTempStandardDataComReqDto reqDto){


      //virtualUsage M3约定业务数据对象等  69366
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setBusinessDataSetTableName("oms_execute_cycle_stage");//CUSTOM_CONVENTION//sourceId:1827685_1_69366
receptionServiceReq.setRedisDataObjectCatalogue("分段查询临时记录");//sourceId:1827683_1_69366
receptionServiceReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1827800_1_69366

    /*M3约定业务数据对象等[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBusinessDataSetTableName(),"D3分段全量周期刷评价模板标准数据(公共)-M3约定业务数据对象等-业务数据对象表名不能为空",false);
Assert.isNull(receptionServiceReq.getRedisDataObjectCatalogue(),"D3分段全量周期刷评价模板标准数据(公共)-M3约定业务数据对象等-Redis数据对象目录不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3分段全量周期刷评价模板标准数据(公共)-M3约定业务数据对象等-关联目标内容类型编码不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



//virtualUsage M3执行死循环(特殊方法）  69367
      //ModelCode: endlessLoop
      // TODO: 2024/5/31
      while(true) {


//virtualUsage D2-查询redis业务数据对象详情（业务原子）  69369
          QueryRedisBusinessDataSetDetailComRespDto queryRedisBusinessDataSetDetailComRespDto = null;
          QueryRedisBusinessDataSetDetailComReqDto queryRedisBusinessDataSetDetailComReqDto = new QueryRedisBusinessDataSetDetailComReqDto();
          if (receptionServiceRes != null) {
              queryRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827794_1_69369
              queryRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827796_1_69369
          }
          if (reqDto != null) {
              queryRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827795_1_69369
          }

          /*D2-查询redis业务数据对象详情（业务原子）[8411]   */
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D3分段全量周期刷评价模板标准数据(公共)-D2-查询redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D3分段全量周期刷评价模板标准数据(公共)-D2-查询redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D3分段全量周期刷评价模板标准数据(公共)-D2-查询redis业务数据对象详情（业务原子）-数据对象批次标识不能为空", false);
          queryRedisBusinessDataSetDetailComRespDto = fwCompBusinessAtomClient.queryRedisBusinessDataSetDetailCom(queryRedisBusinessDataSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3分段查执行周期阶段(公共)  69370
          ImplementSegQueryExecuteCycleComRespDto implementSegQueryExecuteCycleComRespDto = null;
          if (queryRedisBusinessDataSetDetailComRespDto != null) {
              ImplementSegQueryExecuteCycleComReqDto implementSegQueryExecuteCycleComReqDto = new ImplementSegQueryExecuteCycleComReqDto();
              implementSegQueryExecuteCycleComReqDto.setDatasNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1827321_1_69370
              implementSegQueryExecuteCycleComReqDto.setOrderFieldName("orderNumber");//CUSTOM_CONVENTION//sourceId:1827322_1_69370
              implementSegQueryExecuteCycleComReqDto.setOrderRule("FROM_LARGE_TO_SMALL");//sourceId:1827323_1_69370
              implementSegQueryExecuteCycleComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//CUSTOM_CONVENTION//sourceId:1827333_1_69370
              if (receptionServiceRes != null) {
                  implementSegQueryExecuteCycleComReqDto.setBusinessDataSetTableName(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827320_1_69370
                  implementSegQueryExecuteCycleComReqDto.setRelateContentTypeCode(receptionServiceRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1827329_1_69370
              }
              if (queryRedisBusinessDataSetDetailComRespDto != null) {
                  implementSegQueryExecuteCycleComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1827324_1_69370
              }
              if (reqDto != null) {
                  implementSegQueryExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1827331_1_69370
              }

              /*D3分段查执行周期阶段(公共)[9678]   */
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getBusinessDataSetTableName(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-业务数据对象表名不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getDatasNum(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-数据条数不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getOrderFieldName(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-排序字段名不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getOrderRule(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-排序规则不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getRelateContentTypeCode(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getEvaluationTemplateId(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-评价模板ID不能为空", false);
              Assert.isNull(implementSegQueryExecuteCycleComReqDto.getSubjectLifeCycle(), "D3分段全量周期刷评价模板标准数据(公共)-D3分段查执行周期阶段(公共)-主体生命周期不能为空", false);
              implementSegQueryExecuteCycleComRespDto = implementSegQueryExecuteCycleCom(implementSegQueryExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;


          }
          if ((implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().size() > 0)) {
              //if(D3分段查更新执行周期阶段(周期排序从小到大).执行周期阶段列表数据集条数 大于 0)  69371

              RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordComRespDto = null;
              if (implementSegQueryExecuteCycleComRespDto != null && queryRedisBusinessDataSetDetailComRespDto != null) {
                  RefreshSegQueryRedisRecordComReqDto refreshSegQueryRedisRecordComReqDto = new RefreshSegQueryRedisRecordComReqDto();
                  refreshSegQueryRedisRecordComReqDto.setBusinessDataSetPrimaryKeyName("executeCycleStageId");//CUSTOM_CONVENTION//sourceId:1827319_1_69376
                  if (implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList())) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataSetList(implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().stream().map(item -> String.valueOf(item.getExecuteCycleStageId()))
                              .collect(Collectors.toList()));/*list-to-strings*///sourceId:1827314_1_69376
                  }
                  if (receptionServiceRes != null) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827315_1_69376
                      refreshSegQueryRedisRecordComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827316_1_69376
                  }
                  if (reqDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827317_1_69376
                  }
                  if (queryRedisBusinessDataSetDetailComRespDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1827318_1_69376
                  }

                  /*D2更新分段查询Redis记录(公共)[9679]   */
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataObject(), "D3分段全量周期刷评价模板标准数据(公共)-D2更新分段查询Redis记录(公共)-业务数据对象不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getRedisDataObjectCatalogue(), "D3分段全量周期刷评价模板标准数据(公共)-D2更新分段查询Redis记录(公共)-Redis数据对象目录不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getDataObjectBatchCode(), "D3分段全量周期刷评价模板标准数据(公共)-D2更新分段查询Redis记录(公共)-数据对象批次标识不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataSetPrimaryKeyName(), "D3分段全量周期刷评价模板标准数据(公共)-D2更新分段查询Redis记录(公共)-业务数据对象主键名不能为空", false);
                  refreshSegQueryRedisRecordComRespDto = fwCompEvaCalcClient.refreshSegQueryRedisRecordCom(refreshSegQueryRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


              }
//ModelCode: circulationCollections
              for (ExecuteCycleStageDto circulationCollectionsRes : implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList()) {

//ModelCode: circulationEnd
              }

          } else if ((implementSegQueryExecuteCycleComRespDto != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList() != null && implementSegQueryExecuteCycleComRespDto.getExecuteCycleStageList().size() == 0)) {
              //elseif(D3分段查更新执行周期阶段(周期排序从小到大).执行周期阶段列表数据集条数 等于 0)  69372

              DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
              DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto = new DeleteRedisBusinessDataComReqDto();
              deleteRedisBusinessDataComReqDto.setIsDataList("FALSE");//sourceId:1827312_1_69373
              if (receptionServiceRes != null) {
                  deleteRedisBusinessDataComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827309_1_69373
                  deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827313_1_69373
              }
              if (reqDto != null) {
                  deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827311_1_69373
              }

              /*D2-删除redis业务数据对象(公共)[8397]   */
              Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(), "D3分段全量周期刷评价模板标准数据(公共)-D2-删除redis业务数据对象(公共)-业务数据对象不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(), "D3分段全量周期刷评价模板标准数据(公共)-D2-删除redis业务数据对象(公共)-Redis数据对象目录不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getDataObjectBatchCode(), "D3分段全量周期刷评价模板标准数据(公共)-D2-删除redis业务数据对象(公共)-数据对象批次标识不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(), "D3分段全量周期刷评价模板标准数据(公共)-D2-删除redis业务数据对象(公共)-是否是数据集对象不能为空", false);
              deleteRedisBusinessDataComRespDto = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: end
              // TODO: 2024/5/31
              break;


          }
      }
ImplementSegAllCycleBrushEvaTempStandardDataComRespDto retData = new ImplementSegAllCycleBrushEvaTempStandardDataComRespDto();





return retData;
  }
/**
   * D3更新目标周期进展状态(公共)[9826]
   * gen by moon at 6/17/2024, 7:20:13 PM
   */
  @Trace(operationName = "D3更新目标周期进展状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshTargetCycleProgressiveStateComRespDto refreshTargetCycleProgressiveStateCom(RefreshTargetCycleProgressiveStateComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleList() !=null && reqDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3更新目标周期进展状态(公共).被评对象目标周期列表数据集条数 大于 0)  70143

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleList()){

if((circulationCollectionsRes!= null&& circulationCollectionsRes.getTaskStatus() == null ||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTaskStatus() !=null && circulationCollectionsRes.getTaskStatus().equals("NOT_AT_THE"))) {
        //if((M3目标周期【循环开始】.目标周期进展状态 值等于空  or M3目标周期【循环开始】.目标周期进展状态 等于 未开始))  70146

OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
    QueryStartTimeByTargetCyclePsetDetailReq queryStartTimeByTargetCyclePsetDetailReq=new QueryStartTimeByTargetCyclePsetDetailReq();
  queryStartTimeByTargetCyclePsetDetailReq.setIsArchive("FALSE");//sourceId:1874616_1_70148
queryStartTimeByTargetCyclePsetDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1874617_1_70148
if(circulationCollectionsRes!=null){
      queryStartTimeByTargetCyclePsetDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1874613_1_70148
    }
if(reqDto!=null){
      queryStartTimeByTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1874615_1_70148
    }

    /*3-3-08查询开始时间匹配目标周期规划设置详情[7444]   */
    Assert.isNull(queryStartTimeByTargetCyclePsetDetailReq.getEvaObjTargetCycleId(),"D3更新目标周期进展状态(公共)-3-3-08查询开始时间匹配目标周期规划设置详情-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryStartTimeByTargetCyclePsetDetailReq.getEvaluationTemplateId(),"D3更新目标周期进展状态(公共)-3-3-08查询开始时间匹配目标周期规划设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryStartTimeByTargetCyclePsetDetailReq.getIsArchive(),"D3更新目标周期进展状态(公共)-3-3-08查询开始时间匹配目标周期规划设置详情-是否存档不能为空",false);
Assert.isNull(queryStartTimeByTargetCyclePsetDetailReq.getSpaceId(),"D3更新目标周期进展状态(公共)-3-3-08查询开始时间匹配目标周期规划设置详情-创建于空间ID不能为空",false);
      omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryStartTimeByTargetCyclePsetDetail(queryStartTimeByTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsTargetCyclePlanSet !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  checkTimeScopeSearchComReqDto.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1874789_1_70162
if(omsTargetCyclePlanSet!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1874791_1_70162
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3更新目标周期进展状态(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3更新目标周期进展状态(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(omsTargetCyclePlanSet !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  checkTimeScopeSearchComReqDto_1.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1874789_1_70163
if(omsTargetCyclePlanSet!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1874791_1_70163
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3更新目标周期进展状态(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3更新目标周期进展状态(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))&&(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")||checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE"))) {
        //if((D2系统当前时间与成果汇报开始时间比较.时间比较结果 等于 之后（大于） or D2系统当前时间与成果汇报开始时间比较.时间比较结果 等于 当前（等于）) and (D2系统当前时间与成果汇报结束时间比较.时间比较结果 等于 当前（等于） or D2系统当前时间与成果汇报结束时间比较.时间比较结果 等于 之前（小于）))  70149

boolean bOOLEAN ;
    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle=new OmsEvaluationObjectTargetCycle();
  omsEvaluationObjectTargetCycle.setTaskStatus("ONGOING");//sourceId:1874775_1_70152
omsEvaluationObjectTargetCycle.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1874776_1_70152
omsEvaluationObjectTargetCycle.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1874777_1_70152
if(circulationCollectionsRes!=null){
      omsEvaluationObjectTargetCycle.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1874774_1_70152
    }

    /*3-3-09修改被评对象目标周期（进行中）[2317]   */
    Assert.isNull(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（进行中）-被评对象目标周期ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getTaskStatus(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（进行中）-目标周期进展状态不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getOperationInductionId(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（进行中）-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getOperateTime(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（进行中）-操作时间不能为空",false);
      bOOLEAN = mOmsEvaluationObjectTargetCycleService.updateEvaObjTargetCycle(omsEvaluationObjectTargetCycle)/*vcase invoke 本地 method 方法调用;*/;



if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getEvaObjTypeCode() !=null && circulationCollectionsRes.getEvaObjTypeCode().equals("EVA_OBJECT")&&circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetCycleContentTypeCode() !=null && circulationCollectionsRes.getTargetCycleContentTypeCode().equals("TARGET")&&circulationCollectionsRes!= null&&  circulationCollectionsRes.getIsParentCycle() !=null && circulationCollectionsRes.getIsParentCycle().equals("TRUE"))) {
        //if((M3目标周期【循环开始】.被评对象类型编码 等于 评价对象 and M3目标周期【循环开始】.关联目标内容类型编码 等于 目标 and M3目标周期【循环开始】.是否父周期 等于 是))  70166

boolean bOOLEAN_1 ;
    OmsTarget omsTarget=new OmsTarget();
  omsTarget.setTargetPgsStatus("ONGOING");//sourceId:1874773_1_70167
if(circulationCollectionsRes!=null){
      omsTarget.setTargetId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1874772_1_70167
    }

    /*3-3-01修改目标（目标进行中状态）[3625]   */
    Assert.isNull(omsTarget.getTargetId(),"D3更新目标周期进展状态(公共)-3-3-01修改目标（目标进行中状态）-目标ID不能为空",false);
Assert.isNull(omsTarget.getTargetPgsStatus(),"D3更新目标周期进展状态(公共)-3-3-01修改目标（目标进行中状态）-目标进展状态不能为空",false);
      bOOLEAN_1 = mOmsTargetService.updateTarget(omsTarget)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
else if((circulationCollectionsRes!= null&& circulationCollectionsRes.getTaskStatus() == null &&checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE"))){
       //elseif((M3目标周期【循环开始】.目标周期进展状态 值等于空  and D2系统当前时间与成果汇报开始时间比较.时间比较结果 等于 之前（小于）))  70150

boolean bOOLEAN_2 ;
    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1=new OmsEvaluationObjectTargetCycle();
  omsEvaluationObjectTargetCycle_1.setTaskStatus("NOT_AT_THE");//sourceId:1874779_1_70151
omsEvaluationObjectTargetCycle_1.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1874780_1_70151
omsEvaluationObjectTargetCycle_1.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1874781_1_70151
if(circulationCollectionsRes!=null){
      omsEvaluationObjectTargetCycle_1.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1874778_1_70151
    }

    /*3-3-09修改被评对象目标周期（未开始）[2317]   */
    Assert.isNull(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（未开始）-被评对象目标周期ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle_1.getTaskStatus(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（未开始）-目标周期进展状态不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle_1.getOperationInductionId(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（未开始）-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle_1.getOperateTime(),"D3更新目标周期进展状态(公共)-3-3-09修改被评对象目标周期（未开始）-操作时间不能为空",false);
      bOOLEAN_2 = mOmsEvaluationObjectTargetCycleService.updateEvaObjTargetCycle(omsEvaluationObjectTargetCycle_1)/*vcase invoke 本地 method 方法调用;*/;



    }
      }
//ModelCode: circulationEnd
        }

      }
RefreshTargetCycleProgressiveStateComRespDto retData = new RefreshTargetCycleProgressiveStateComRespDto();





return retData;
  }
/**
   * D3分析任务所属目标归属周期(公共)[9837]
   * gen by moon at 6/21/2024, 1:09:13 PM
   */
  @Trace(operationName = "D3分析任务所属目标归属周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisTaskOfTargetCycleComRespDto analysisTaskOfTargetCycleCom(AnalysisTaskOfTargetCycleComReqDto reqDto){


      OmsTargetAttributionCycle omsTargetAttributionCycle_1 =null;
QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto_1 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1880796_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1880797_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTaskId(),"D3分析任务所属目标归属周期(公共)-M3接收入参字段-任务ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3分析任务所属目标归属周期(公共)-M3接收入参字段-空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);




//步骤1: 3-3-11查周期阶段资料详情 - queryCycleStageDataDetail
     OmsTspeCycleStageData omsTspeCycleStageData = null;
    QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  queryCycleStageDataDetailReq.setIsArchive("FALSE");//sourceId:1880848_1
if(reqDto!=null){
      queryCycleStageDataDetailReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1880847_1
queryCycleStageDataDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1880849_1
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getTaskId(),"D3分析任务所属目标归属周期(公共)-3-3-11查周期阶段资料详情-任务ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getIsArchive(),"D3分析任务所属目标归属周期(公共)-3-3-11查周期阶段资料详情-是否存档不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getSpaceId(),"D3分析任务所属目标归属周期(公共)-3-3-11查周期阶段资料详情-创建于空间ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: 3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情 - queryTargetBelongCycleByGeStartAndLeEndTimeDetail
     OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    if(omsTspeCycleStageData !=null){
          QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq=new QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq();
  if(omsTspeCycleStageData!=null){
      queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setCycleId(omsTspeCycleStageData.getCycleId());//SimpleFieldAssign//sourceId:1880952_1
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setEntityId(omsTspeCycleStageData.getCycleDataObjId());//SimpleFieldAssign//sourceId:1880958_1
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setParentSubMidCycleType(omsTspeCycleStageData.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1880959_1
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setEvaluationTemplateId(omsTspeCycleStageData.getThemeContentId());//SimpleFieldAssign//sourceId:1880960_1
    }
if(reqDto!=null){
      queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1880953_1
    }

    /*3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情[9578]   */
    Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getCycleId(),"D3分析任务所属目标归属周期(公共)-3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情-归属周期ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getEntityId(),"D3分析任务所属目标归属周期(公共)-3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getParentSubMidCycleType(),"D3分析任务所属目标归属周期(公共)-3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getEvaluationTemplateId(),"D3分析任务所属目标归属周期(公共)-3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getSpaceId(),"D3分析任务所属目标归属周期(公共)-3-3-09-07查询目标归属周期（大于等于开始时间&小于等于结束时间）详情-创建于空间ID不能为空",false);
      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByGeStartAndLeEndTimeDetail(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetAttributionCycle_1 = omsTargetAttributionCycle;
           }

//步骤3: D3-查询上一个执行周期的周期及目标周期详情(公共) - queryLastExecCycleAndTargetCycleDetailCom
     QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    if(omsTspeCycleStageData !=null){
          QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
  if(omsTspeCycleStageData!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(omsTspeCycleStageData.getCycleId());//SimpleFieldAssign//sourceId:1881290_1
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(omsTspeCycleStageData.getCycleDataObjId());//SimpleFieldAssign//sourceId:1881289_1
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(omsTspeCycleStageData.getThemeContentId());//SimpleFieldAssign//sourceId:1881291_1
    }

    /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D3分析任务所属目标归属周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3分析任务所属目标归属周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3分析任务所属目标归属周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


      queryLastExecCycleAndTargetCycleDetailComRespDto_1 = queryLastExecCycleAndTargetCycleDetailComRespDto;
           }

AnalysisTaskOfTargetCycleComRespDto retData = new AnalysisTaskOfTargetCycleComRespDto();
  if(omsTargetAttributionCycle_1!=null){
      retData.setTargetAttributionCycleId(omsTargetAttributionCycle_1.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1881054_1
retData.setSubCycleCalcModelId(omsTargetAttributionCycle_1.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:1881579_1
retData.setMidCycleCalcModelId(omsTargetAttributionCycle_1.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:1881580_1
retData.setParentCycleCalcModelId(omsTargetAttributionCycle_1.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:1881581_1
retData.setBelongToPersonalIdentityId(omsTargetAttributionCycle_1.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1881582_1
retData.setIsUseFirstDept(omsTargetAttributionCycle_1.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1881583_1
retData.setDashboradPrimaryDeptId(omsTargetAttributionCycle_1.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:1881584_1
    }
if(queryLastExecCycleAndTargetCycleDetailComRespDto_1!=null){
      retData.setLastCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastCycleId());//SimpleFieldAssign//sourceId:1881301_1
    }




return retData;
  }
/**
   * D3更新汇报任务统计数据(公共)[9840]
   * gen by moon at 6/21/2024, 1:09:26 PM
   */
  @Trace(operationName = "D3更新汇报任务统计数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshReportTaskTotalDataComRespDto refreshReportTaskTotalDataCom(RefreshReportTaskTotalDataComReqDto reqDto){


      //virtualUsage D3分析任务所属目标归属周期(公共)  70452
      AnalysisTaskOfTargetCycleComRespDto analysisTaskOfTargetCycleComRespDto = null;
    AnalysisTaskOfTargetCycleComReqDto analysisTaskOfTargetCycleComReqDto=new AnalysisTaskOfTargetCycleComReqDto();


    /*D3分析任务所属目标归属周期(公共)[9837]   */
    Assert.isNull(analysisTaskOfTargetCycleComReqDto.getTaskId(),"D3更新汇报任务统计数据(公共)-D3分析任务所属目标归属周期(公共)-任务ID不能为空",false);
Assert.isNull(analysisTaskOfTargetCycleComReqDto.getSpaceId(),"D3更新汇报任务统计数据(公共)-D3分析任务所属目标归属周期(公共)-空间ID不能为空",false);
      analysisTaskOfTargetCycleComRespDto = analysisTaskOfTargetCycleCom(analysisTaskOfTargetCycleComReqDto)/*vcase invoke 同服务,同domain*/;



if((analysisTaskOfTargetCycleComRespDto!= null&& analysisTaskOfTargetCycleComRespDto.getSubCycleCalcModelId() != null )) {
        //if(D3分析任务所属目标归属周期(公共).子周期计算模型ID 值不等于空 )  70453

      }
if((analysisTaskOfTargetCycleComRespDto!= null&& analysisTaskOfTargetCycleComRespDto.getMidCycleCalcModelId() != null )) {
        //if(D3分析任务所属目标归属周期(公共).中期计算模型ID 值不等于空 )  70457

      }
if((analysisTaskOfTargetCycleComRespDto!= null&& analysisTaskOfTargetCycleComRespDto.getParentCycleCalcModelId() != null )) {
        //if(D3分析任务所属目标归属周期(公共).父周期计算模型ID 值不等于空 )  70456

      }
RefreshReportTaskTotalDataComRespDto retData = new RefreshReportTaskTotalDataComRespDto();





return retData;
  }
/**
   * D3执行目标分类及指标统计数据(公共)[9841]
   * gen by moon at 6/26/2024, 5:03:29 PM
   */
  @Trace(operationName = "D3执行目标分类及指标统计数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetCategoryAndObjectiveTotalDataComRespDto implementTargetCategoryAndObjectiveTotalDataCom(ImplementTargetCategoryAndObjectiveTotalDataComReqDto reqDto){


      StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))) {
        //if((D3执行目标分类及指标统计数据(公共).父子中过程周期类型 等于 父周期 or D3执行目标分类及指标统计数据(公共).父子中过程周期类型 等于 中期))  70532

QueryCurAndAncestorTargetAttributionCycleListComRespDto queryCurAndAncestorTargetAttributionCycleListComRespDto = null;
    QueryCurAndAncestorTargetAttributionCycleListComReqDto queryCurAndAncestorTargetAttributionCycleListComReqDto=new QueryCurAndAncestorTargetAttributionCycleListComReqDto();
  if(reqDto!=null){
      queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1883413_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1883414_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1883415_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1883420_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setTargetContentLevelNumber(reqDto.getTargetContentLevelNumber());//SimpleFieldAssign//sourceId:1883421_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:1896703_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setIsLastCategory(reqDto.getIsLastCategory());//SimpleFieldAssign//sourceId:1899462_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setOneLevelCategoryId(reqDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1899463_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setCorrelationLastTargetCatId(reqDto.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:1899464_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setDashboradPrimaryDeptId(reqDto.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:1883582_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setDashboradBasicDeptId(reqDto.getDashboradBasicDeptId());//SimpleFieldAssign//sourceId:1883583_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setDashboradOriginalRoleMemberId(reqDto.getDashboradOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883584_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setDashboradDirectorOriginalRoleMemberId(reqDto.getDashboradDirectorOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883585_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setDashboradDeptLeaderOriginalRoleMemberId(reqDto.getDashboradDeptLeaderOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883586_1_70533
queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1883422_1_70533
    }

    /*D3查询目标归属周期列表(公共)[9728]   */

      queryCurAndAncestorTargetAttributionCycleListComRespDto = targetCalcService.queryCurAndAncestorTargetAttributionCycleListCom(queryCurAndAncestorTargetAttributionCycleListComReqDto)/*vcase invoke isSameApp*/;



StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto = null;
    if(queryCurAndAncestorTargetAttributionCycleListComRespDto !=null){
          StatisticsTargetContentAndComAndComRateComReqDto statisticsTargetContentAndComAndComRateComReqDto=new StatisticsTargetContentAndComAndComRateComReqDto();
  statisticsTargetContentAndComAndComRateComReqDto.setIsReached("TRUE");//sourceId:1897135_1_70899
  if(queryCurAndAncestorTargetAttributionCycleListComRespDto!= null&&  queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList())){
      statisticsTargetContentAndComAndComRateComReqDto.setEvaObjTargetCycleList(queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1897134_1_70899
    }
if(reqDto!=null){
      statisticsTargetContentAndComAndComRateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1897136_1_70899
    }

    /*D3统计目标内容数与完成数与完成率(公共)[9875]   */
    Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto.getIsReached(),"D3执行目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-目标是否达成不能为空",false);
Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto.getEvaluationTemplateId(),"D3执行目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-冗余评价模板ID不能为空",false);
      statisticsTargetContentAndComAndComRateComRespDto = statisticsTargetContentAndComAndComRateCom(statisticsTargetContentAndComAndComRateComReqDto)/*vcase invoke 同服务,同domain*/;


      statisticsTargetContentAndComAndComRateComRespDto_1 = statisticsTargetContentAndComAndComRateComRespDto;
      }
      }
else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE"))){
       //elseif(D3执行目标分类及指标统计数据(公共).父子中过程周期类型 等于 子周期)  70534

QueryCurAndAncestorTargetAttributionCycleListComRespDto queryCurAndAncestorTargetAttributionCycleListComRespDto_2 = null;
    QueryCurAndAncestorTargetAttributionCycleListComReqDto queryCurAndAncestorTargetAttributionCycleListComReqDto_1=new QueryCurAndAncestorTargetAttributionCycleListComReqDto();
  if(reqDto!=null){
      queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1883413_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1883414_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1883415_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setTargetCycleId(reqDto.getTargetCycleId());//SimpleFieldAssign//sourceId:1883444_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1883420_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setTargetContentLevelNumber(reqDto.getTargetContentLevelNumber());//SimpleFieldAssign//sourceId:1883421_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:1896703_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setIsLastCategory(reqDto.getIsLastCategory());//SimpleFieldAssign//sourceId:1899462_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setOneLevelCategoryId(reqDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1899463_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setCorrelationLastTargetCatId(reqDto.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:1899464_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setDashboradPrimaryDeptId(reqDto.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:1883582_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setDashboradBasicDeptId(reqDto.getDashboradBasicDeptId());//SimpleFieldAssign//sourceId:1883583_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setDashboradOriginalRoleMemberId(reqDto.getDashboradOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883584_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setDashboradDirectorOriginalRoleMemberId(reqDto.getDashboradDirectorOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883585_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setDashboradDeptLeaderOriginalRoleMemberId(reqDto.getDashboradDeptLeaderOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1883586_1_70535
queryCurAndAncestorTargetAttributionCycleListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1883422_1_70535
    }

    /*D3查询目标归属周期列表(公共)[9728]   */

      queryCurAndAncestorTargetAttributionCycleListComRespDto_2 = targetCalcService.queryCurAndAncestorTargetAttributionCycleListCom(queryCurAndAncestorTargetAttributionCycleListComReqDto_1)/*vcase invoke isSameApp*/;



StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto_2 = null;
    if(queryCurAndAncestorTargetAttributionCycleListComRespDto_2 !=null){
          StatisticsTargetContentAndComAndComRateComReqDto statisticsTargetContentAndComAndComRateComReqDto_1=new StatisticsTargetContentAndComAndComRateComReqDto();
  statisticsTargetContentAndComAndComRateComReqDto_1.setIsReached("TRUE");//sourceId:1897135_1_70900
  if(queryCurAndAncestorTargetAttributionCycleListComRespDto_2!= null&&  queryCurAndAncestorTargetAttributionCycleListComRespDto_2.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryCurAndAncestorTargetAttributionCycleListComRespDto_2.getTargetBelongCycleList())){
      statisticsTargetContentAndComAndComRateComReqDto_1.setEvaObjTargetCycleList(queryCurAndAncestorTargetAttributionCycleListComRespDto_2.getTargetBelongCycleList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1897134_1_70900
    }
if(reqDto!=null){
      statisticsTargetContentAndComAndComRateComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1897136_1_70900
    }

    /*D3统计目标内容数与完成数与完成率(公共)[9875]   */
    Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto_1.getIsReached(),"D3执行目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-目标是否达成不能为空",false);
Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto_1.getEvaluationTemplateId(),"D3执行目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-冗余评价模板ID不能为空",false);
      statisticsTargetContentAndComAndComRateComRespDto_2 = statisticsTargetContentAndComAndComRateCom(statisticsTargetContentAndComAndComRateComReqDto_1)/*vcase invoke 同服务,同domain*/;


      statisticsTargetContentAndComAndComRateComRespDto_1 = statisticsTargetContentAndComAndComRateComRespDto_2;
      }
    }
ImplementTargetCategoryAndObjectiveTotalDataComRespDto retData = new ImplementTargetCategoryAndObjectiveTotalDataComRespDto();
  if(statisticsTargetContentAndComAndComRateComRespDto_1!=null){
      retData.setTargetContentNumber(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetContentNumber());//SimpleFieldAssign//sourceId:1897148_1
retData.setTargetCompletionNum(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetCompletionNum());//SimpleFieldAssign//sourceId:1897149_1
retData.setTargetCompletionRate(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetCompletionRate());//SimpleFieldAssign//sourceId:1897150_1
    }




return retData;
  }
/**
   * D3分析目标父子中周期类型(公共)[9842]
   * gen by moon at 6/23/2024, 10:56:33 AM
   */
  @Trace(operationName = "D3分析目标父子中周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisTargetParentSubMidCycleTypeComRespDto analysisTargetParentSubMidCycleTypeCom(AnalysisTargetParentSubMidCycleTypeComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
      //virtualUsage M3-约定字段：父、中、子周期类型  70520
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1884092_1_70520
receptionServiceReq.setCustomField2("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:1884093_1_70520
receptionServiceReq.setCustomField3("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1884094_1_70520

    /*M3-约定字段：父、中、子周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析目标父子中周期类型(公共)-M3-约定字段：父、中、子周期类型-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析目标父子中周期类型(公共)-M3-约定字段：父、中、子周期类型-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3分析目标父子中周期类型(公共)-M3-约定字段：父、中、子周期类型-自定义字段3不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE")&&reqDto!= null&&  reqDto.getIsParentCycle() !=null && reqDto.getIsParentCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))) {
        //if((D3分析目标父子中周期类型(公共).周期模式类型编码 等于 父子周期 and D3分析目标父子中周期类型(公共).是否父周期 等于 是 and D3分析目标父子中周期类型(公共).是否中期 等于 否 and D3分析目标父子中周期类型(公共).是否子周期 等于 否))  70519

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1884348_1_70528
    }

    /*M3-接收出参字段：父子中周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D3分析目标父子中周期类型(公共)-M3-接收出参字段：父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE")&&reqDto!= null&&  reqDto.getIsParentCycle() !=null && reqDto.getIsParentCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))){
       //elseif((D3分析目标父子中周期类型(公共).周期模式类型编码 等于 父子周期 and D3分析目标父子中周期类型(公共).是否父周期 等于 否 and D3分析目标父子中周期类型(公共).是否中期 等于 是 and D3分析目标父子中周期类型(公共).是否子周期 等于 否))  70521

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1884348_1_70527
    }

    /*M3-接收出参字段：父子中周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D3分析目标父子中周期类型(公共)-M3-接收出参字段：父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE")&&reqDto!= null&&  reqDto.getIsParentCycle() !=null && reqDto.getIsParentCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE"))){
       //elseif((D3分析目标父子中周期类型(公共).周期模式类型编码 等于 父子周期 and D3分析目标父子中周期类型(公共).是否父周期 等于 否 and D3分析目标父子中周期类型(公共).是否中期 等于 否 and D3分析目标父子中周期类型(公共).是否子周期 等于 是))  70522

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1884348_1_70526
    }

    /*M3-接收出参字段：父子中周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(),"D3分析目标父子中周期类型(公共)-M3-接收出参字段：父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE"))){
       //elseif((D3分析目标父子中周期类型(公共).周期模式类型编码 等于 单周期 or D3分析目标父子中周期类型(公共).周期模式类型编码 等于 不规则周期))  70524

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_4=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1884348_1_70525
    }

    /*M3-接收出参字段：父子中周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(),"D3分析目标父子中周期类型(公共)-M3-接收出参字段：父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_6 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
else{
       //else  70529

//异常结束 70530
      throw new BizException("3300330400462","对不起，目标的目标周期数据异常~",false);
    }
AnalysisTargetParentSubMidCycleTypeComRespDto retData = new AnalysisTargetParentSubMidCycleTypeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1889479_1
    }




return retData;
  }
/**
   * D3统计评价模板下指标或目标分类完成数(公共)[9859]
   * gen by moon at 6/23/2024, 9:27:00 PM
   */
  @Trace(operationName = "D3统计评价模板下指标或目标分类完成数(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public StatisticsEvaTempCategoryOrObjtivePerfectNumComRespDto statisticsEvaTempCategoryOrObjtivePerfectNumCom(StatisticsEvaTempCategoryOrObjtivePerfectNumComReqDto reqDto){


      ImplementSixReceivingFieldRespDto receptionServiceRes_3 =null;
ImplementSixReceivingFieldRespDto receptionServiceRes_5 =null;
//virtualUsage M3接收入参字段  70728
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setLevelNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1890097_1_70728
receptionServiceReq.setTureOrFalse("TRUE");//sourceId:1890098_1_70728
if(reqDto!=null){
      receptionServiceReq.setCalcBusinessScence(reqDto.getCalcBusinessScence());//SimpleFieldAssign//sourceId:1890089_1_70728
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1890001_1_70728
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1890000_1_70728
receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1890079_1_70728
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1890003_1_70728
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1889999_1_70728
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890069_1_70728
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCalcBusinessScence(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-计算业务场景不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getParentSubMidCycleType(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-父子中过程周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getLevelNumber(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-层级不能为空",false);
Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收入参字段-是否不能为空",false);
      receptionServiceRes = nbEvaCalc.implementFiveReceivingField(receptionServiceReq);



//virtualUsage D3执行转单字段父子中周期类型(公共)  70715
      ImplementTurnSingleFieldParentSubMidCycleTypeComRespDto implementTurnSingleFieldParentSubMidCycleTypeComRespDto = null;
    ImplementTurnSingleFieldParentSubMidCycleTypeComReqDto implementTurnSingleFieldParentSubMidCycleTypeComReqDto=new ImplementTurnSingleFieldParentSubMidCycleTypeComReqDto();
  if(reqDto!=null){
      implementTurnSingleFieldParentSubMidCycleTypeComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1890076_1_70715
implementTurnSingleFieldParentSubMidCycleTypeComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1890071_1_70715
    }

    /*D3执行转单字段父子中周期类型(公共)[9319]   */
    Assert.isNull(implementTurnSingleFieldParentSubMidCycleTypeComReqDto.getCycleId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3执行转单字段父子中周期类型(公共)-周期ID不能为空",false);
Assert.isNull(implementTurnSingleFieldParentSubMidCycleTypeComReqDto.getParentSubMidCycleType(),"D3统计评价模板下指标或目标分类完成数(公共)-D3执行转单字段父子中周期类型(公共)-父子中周期类型不能为空",false);
      implementTurnSingleFieldParentSubMidCycleTypeComRespDto = dashboardTargetContentService.implementTurnSingleFieldParentSubMidCycleTypeCom(implementTurnSingleFieldParentSubMidCycleTypeComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3查询评价模板下目标分类列表(公共)  70714
      QueryEvaTempTargetCategoryListComRespDto queryEvaTempTargetCategoryListComRespDto = null;
    QueryEvaTempTargetCategoryListComReqDto queryEvaTempTargetCategoryListComReqDto=new QueryEvaTempTargetCategoryListComReqDto();
  queryEvaTempTargetCategoryListComReqDto.setIsLast("TRUE");//sourceId:1890050_1_70714
queryEvaTempTargetCategoryListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1890053_1_70714
if(reqDto!=null){
      queryEvaTempTargetCategoryListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890051_1_70714
    }

    /*D3查询评价模板下目标分类列表(公共)[9860]   */
    Assert.isNull(queryEvaTempTargetCategoryListComReqDto.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下目标分类列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTempTargetCategoryListComReqDto.getIsLast(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下目标分类列表(公共)-目标分类是否末级不能为空",false);
Assert.isNull(queryEvaTempTargetCategoryListComReqDto.getSubjectLifeCycle(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下目标分类列表(公共)-主体生命周期不能为空",false);
      queryEvaTempTargetCategoryListComRespDto = queryEvaTempTargetCategoryListCom(queryEvaTempTargetCategoryListComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D3批量查询被评对象目标周期By内容ID(公共)  70716
      BatchQueryEvaObjTargetCycleByContIdComRespDto batchQueryEvaObjTargetCycleByContIdComRespDto = null;
    if(queryEvaTempTargetCategoryListComRespDto !=null&&implementTurnSingleFieldParentSubMidCycleTypeComRespDto !=null){
          BatchQueryEvaObjTargetCycleByContIdComReqDto batchQueryEvaObjTargetCycleByContIdComReqDto=new BatchQueryEvaObjTargetCycleByContIdComReqDto();
  batchQueryEvaObjTargetCycleByContIdComReqDto.setIsReached("TRUE");//sourceId:1890087_1_70716
if(queryEvaTempTargetCategoryListComRespDto!= null&&  queryEvaTempTargetCategoryListComRespDto.getTargetCatList() !=null&& !CollectionUtil.isEmpty(queryEvaTempTargetCategoryListComRespDto.getTargetCatList())){
      batchQueryEvaObjTargetCycleByContIdComReqDto.setEvaObjTargetCycleList(queryEvaTempTargetCategoryListComRespDto.getTargetCatList().stream().map(item->item.getTargetCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1890058_1_70716
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1890067_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1890059_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890064_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890065_1_70716
    }
if(implementTurnSingleFieldParentSubMidCycleTypeComRespDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto.setCycleId(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1890060_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setIsParentCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1890061_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setIsMetaphase(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1890062_1_70716
batchQueryEvaObjTargetCycleByContIdComReqDto.setIsSubCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1890063_1_70716
    }

    /*D3批量查询被评对象目标周期By内容ID(公共)[9051]   */
    Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto.getEvaObjEntityId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto.getEvaObjTypeCode(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto.getIsReached(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-目标是否达成不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-创建于空间ID不能为空",false);
      batchQueryEvaObjTargetCycleByContIdComRespDto = dashboardTargetContentService.batchQueryEvaObjTargetCycleByContIdCom(batchQueryEvaObjTargetCycleByContIdComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D2统计数据集内容条数服务(公共)  70717
      CalculateContentAmountComRespDto calculateContentAmountComRespDto = null;
    if(batchQueryEvaObjTargetCycleByContIdComRespDto !=null){
          CalculateContentAmountComReqDto calculateContentAmountComReqDto=new CalculateContentAmountComReqDto();
  if(batchQueryEvaObjTargetCycleByContIdComRespDto!= null&&  batchQueryEvaObjTargetCycleByContIdComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(batchQueryEvaObjTargetCycleByContIdComRespDto.getEvaObjTargetCycleList())){
      calculateContentAmountComReqDto.setContentAmountList(batchQueryEvaObjTargetCycleByContIdComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1890082_1_70717
    }

    /*D2统计数据集内容条数服务(公共)[3386]   */

      calculateContentAmountComRespDto = fwCompStatisticalDataClient.calculateContentAmountCom(calculateContentAmountComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D3查询评价模板下指标列表(公共)  70718
      QueryEvaTempObjectiveListComRespDto queryEvaTempObjectiveListComRespDto = null;
    QueryEvaTempObjectiveListComReqDto queryEvaTempObjectiveListComReqDto=new QueryEvaTempObjectiveListComReqDto();
  if(receptionServiceRes!=null){
      queryEvaTempObjectiveListComReqDto.setLevelNumber(receptionServiceRes.getLevelNumber());//SimpleFieldAssign//sourceId:1890015_1_70718
    }
if(reqDto!=null){
      queryEvaTempObjectiveListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890011_1_70718
queryEvaTempObjectiveListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890012_1_70718
    }

    /*D3查询评价模板下指标列表(公共)[8917]   */
    Assert.isNull(queryEvaTempObjectiveListComReqDto.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下指标列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTempObjectiveListComReqDto.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下指标列表(公共)-创建于空间ID不能为空",false);
      queryEvaTempObjectiveListComRespDto = dashboardTargetContentService.queryEvaTempObjectiveListCom(queryEvaTempObjectiveListComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3批量查询被评对象目标周期By内容ID(公共)  70719
      BatchQueryEvaObjTargetCycleByContIdComRespDto batchQueryEvaObjTargetCycleByContIdComRespDto_2 = null;
    if(queryEvaTempObjectiveListComRespDto !=null&&implementTurnSingleFieldParentSubMidCycleTypeComRespDto !=null){
          BatchQueryEvaObjTargetCycleByContIdComReqDto batchQueryEvaObjTargetCycleByContIdComReqDto_1=new BatchQueryEvaObjTargetCycleByContIdComReqDto();
  batchQueryEvaObjTargetCycleByContIdComReqDto_1.setIsReached("TRUE");//sourceId:1890087_1_70719
if(queryEvaTempObjectiveListComRespDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_1.setEvaObjTargetCycleList(queryEvaTempObjectiveListComRespDto.getTargetObjList());//list-field-assign//sourceId:1890058_1_70719
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1890067_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1890059_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890064_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890065_1_70719
    }
if(implementTurnSingleFieldParentSubMidCycleTypeComRespDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_1.setCycleId(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1890060_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setIsParentCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1890061_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setIsMetaphase(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1890062_1_70719
batchQueryEvaObjTargetCycleByContIdComReqDto_1.setIsSubCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1890063_1_70719
    }

    /*D3批量查询被评对象目标周期By内容ID(公共)[9051]   */
    Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_1.getEvaObjEntityId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_1.getEvaObjTypeCode(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_1.getIsReached(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-目标是否达成不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_1.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_1.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-创建于空间ID不能为空",false);
      batchQueryEvaObjTargetCycleByContIdComRespDto_2 = dashboardTargetContentService.batchQueryEvaObjTargetCycleByContIdCom(batchQueryEvaObjTargetCycleByContIdComReqDto_1)/*vcase invoke isSameApp*/;



           }
//virtualUsage D2统计数据集内容条数服务(公共)  70720
      CalculateContentAmountComRespDto calculateContentAmountComRespDto_2 = null;
    if(batchQueryEvaObjTargetCycleByContIdComRespDto_2 !=null){
          CalculateContentAmountComReqDto calculateContentAmountComReqDto_1=new CalculateContentAmountComReqDto();
  if(batchQueryEvaObjTargetCycleByContIdComRespDto_2!= null&&  batchQueryEvaObjTargetCycleByContIdComRespDto_2.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(batchQueryEvaObjTargetCycleByContIdComRespDto_2.getEvaObjTargetCycleList())){
      calculateContentAmountComReqDto_1.setContentAmountList(batchQueryEvaObjTargetCycleByContIdComRespDto_2.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1890082_1_70720
    }

    /*D2统计数据集内容条数服务(公共)[3386]   */

      calculateContentAmountComRespDto_2 = fwCompStatisticalDataClient.calculateContentAmountCom(calculateContentAmountComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage M3接收末级目标分类与一级指标达成数  70729
      //ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_2 = null;
    if(calculateContentAmountComRespDto !=null&&calculateContentAmountComRespDto_2 !=null){
          ImplementSixReceivingFieldReqDto receptionServiceReq_1=new ImplementSixReceivingFieldReqDto();
  if(calculateContentAmountComRespDto!=null){
      receptionServiceReq_1.setLastTargetCategoryAchieveNum(calculateContentAmountComRespDto.getCalcCount());//SimpleFieldAssign//sourceId:1890476_1_70729
    }
if(calculateContentAmountComRespDto_2!=null){
      receptionServiceReq_1.setRootObjectiveAchieveNum(calculateContentAmountComRespDto_2.getCalcCount());//SimpleFieldAssign//sourceId:1890475_1_70729
    }

    /*M3接收末级目标分类与一级指标达成数[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getLastTargetCategoryAchieveNum(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收末级目标分类与一级指标达成数-末级目标分类达成数不能为空",false);
Assert.isNull(receptionServiceReq_1.getRootObjectiveAchieveNum(),"D3统计评价模板下指标或目标分类完成数(公共)-M3接收末级目标分类与一级指标达成数-一级指标达成数不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementSixReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
if((reqDto!= null&&  reqDto.getCalcBusinessScence() !=null && reqDto.getCalcBusinessScence().equals("EVA_OBJECT"))) {
        //if(D3统计评价模板下指标或目标分类完成数(公共).计算业务场景 等于 评价对象)  70724

QueryEvaTempObjectiveListComRespDto queryEvaTempObjectiveListComRespDto_2 = null;
    QueryEvaTempObjectiveListComReqDto queryEvaTempObjectiveListComReqDto_1=new QueryEvaTempObjectiveListComReqDto();
  if(receptionServiceRes!=null){
      queryEvaTempObjectiveListComReqDto_1.setIsLastObjective(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1890014_1_70725
    }
if(reqDto!=null){
      queryEvaTempObjectiveListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890011_1_70725
queryEvaTempObjectiveListComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890012_1_70725
    }

    /*D3查询评价模板下指标列表(公共)[8917]   */
    Assert.isNull(queryEvaTempObjectiveListComReqDto_1.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下指标列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTempObjectiveListComReqDto_1.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3查询评价模板下指标列表(公共)-创建于空间ID不能为空",false);
      queryEvaTempObjectiveListComRespDto_2 = dashboardTargetContentService.queryEvaTempObjectiveListCom(queryEvaTempObjectiveListComReqDto_1)/*vcase invoke isSameApp*/;



BatchQueryEvaObjTargetCycleByContIdComRespDto batchQueryEvaObjTargetCycleByContIdComRespDto_3 = null;
    if(queryEvaTempObjectiveListComRespDto_2 !=null&&implementTurnSingleFieldParentSubMidCycleTypeComRespDto !=null){
          BatchQueryEvaObjTargetCycleByContIdComReqDto batchQueryEvaObjTargetCycleByContIdComReqDto_2=new BatchQueryEvaObjTargetCycleByContIdComReqDto();
  batchQueryEvaObjTargetCycleByContIdComReqDto_2.setIsReached("TRUE");//sourceId:1890087_1_70726
if(queryEvaTempObjectiveListComRespDto_2!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_2.setEvaObjTargetCycleList(queryEvaTempObjectiveListComRespDto_2.getTargetObjList());//list-field-assign//sourceId:1890058_1_70726
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_2.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1890067_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1890059_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890064_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890065_1_70726
    }
if(implementTurnSingleFieldParentSubMidCycleTypeComRespDto!=null){
      batchQueryEvaObjTargetCycleByContIdComReqDto_2.setCycleId(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1890060_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setIsParentCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1890061_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setIsMetaphase(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1890062_1_70726
batchQueryEvaObjTargetCycleByContIdComReqDto_2.setIsSubCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1890063_1_70726
    }

    /*D3批量查询被评对象目标周期By内容ID(公共)[9051]   */
    Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_2.getEvaObjEntityId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_2.getEvaObjTypeCode(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_2.getIsReached(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-目标是否达成不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_2.getEvaluationTemplateId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleByContIdComReqDto_2.getSpaceId(),"D3统计评价模板下指标或目标分类完成数(公共)-D3批量查询被评对象目标周期By内容ID(公共)-创建于空间ID不能为空",false);
      batchQueryEvaObjTargetCycleByContIdComRespDto_3 = dashboardTargetContentService.batchQueryEvaObjTargetCycleByContIdCom(batchQueryEvaObjTargetCycleByContIdComReqDto_2)/*vcase invoke isSameApp*/;



           }
CalculateContentAmountComRespDto calculateContentAmountComRespDto_3 = null;
    if(batchQueryEvaObjTargetCycleByContIdComRespDto_3 !=null){
          CalculateContentAmountComReqDto calculateContentAmountComReqDto_2=new CalculateContentAmountComReqDto();
  if(batchQueryEvaObjTargetCycleByContIdComRespDto_3!= null&&  batchQueryEvaObjTargetCycleByContIdComRespDto_3.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(batchQueryEvaObjTargetCycleByContIdComRespDto_3.getEvaObjTargetCycleList())){
      calculateContentAmountComReqDto_2.setContentAmountList(batchQueryEvaObjTargetCycleByContIdComRespDto_3.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1890082_1_70727
    }

    /*D2统计数据集内容条数服务(公共)[3386]   */

      calculateContentAmountComRespDto_3 = fwCompStatisticalDataClient.calculateContentAmountCom(calculateContentAmountComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_4 = null;
    if(calculateContentAmountComRespDto_3 !=null){
          ImplementSixReceivingFieldReqDto receptionServiceReq_2=new ImplementSixReceivingFieldReqDto();
  if(calculateContentAmountComRespDto_3!=null){
      receptionServiceReq_2.setLastObjectiveAchieveNum(calculateContentAmountComRespDto_3.getCalcCount());//SimpleFieldAssign//sourceId:1890477_1_70730
    }

    /*M3接收末级指标达成数[8635]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbEvaCalc.implementSixReceivingField(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
           }
      }
StatisticsEvaTempCategoryOrObjtivePerfectNumComRespDto retData = new StatisticsEvaTempCategoryOrObjtivePerfectNumComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setLastTargetCategoryAchieveNum(receptionServiceRes_3.getLastTargetCategoryAchieveNum());//SimpleFieldAssign//sourceId:1890480_1
retData.setRootObjectiveAchieveNum(receptionServiceRes_3.getRootObjectiveAchieveNum());//SimpleFieldAssign//sourceId:1890481_1
    }
if(receptionServiceRes_5!=null){
      retData.setLastObjectiveAchieveNum(receptionServiceRes_5.getLastObjectiveAchieveNum());//SimpleFieldAssign//sourceId:1890479_1
    }




return retData;
  }
/**
   * D3查询评价模板下目标分类列表(公共)[9860]
   * gen by moon at 6/23/2024, 8:57:13 PM
   */
  @Trace(operationName = "D3查询评价模板下目标分类列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTempTargetCategoryListComRespDto queryEvaTempTargetCategoryListCom(QueryEvaTempTargetCategoryListComReqDto reqDto){


      List<OmsTargetCategory> listOmsTargetCategory_1 =new ArrayList<>();
//步骤0: 3-3-02查目标分类列表 - queryTargetCatList
     List<OmsTargetCategory> listOmsTargetCategory =new ArrayList<>();
    QueryTargetCatListReq queryTargetCatListReq=new QueryTargetCatListReq();
  if(reqDto!=null){
      queryTargetCatListReq.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1890037_1
queryTargetCatListReq.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1890038_1
queryTargetCatListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1890036_1
queryTargetCatListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1890039_1
queryTargetCatListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1890040_1
    }

    /*3-3-02查目标分类列表[2592]   */

      listOmsTargetCategory = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetCategory_1 = listOmsTargetCategory;

QueryEvaTempTargetCategoryListComRespDto retData = new QueryEvaTempTargetCategoryListComRespDto();
  retData.setTargetCatList(listOmsTargetCategory_1.stream().map(item -> BeanUtil.toBean(item, TargetCatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1890046_1




return retData;
  }
/**
   * D3执行修正进度值/实际值/费用等[9864]
   * gen by moon at 9/26/2024, 6:41:47 PM
   */
  @Trace(operationName = "D3执行修正进度值/实际值/费用等")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAdjustedProgressActualCostAmountEtcRespDto implementAdjustedProgressActualCostAmountEtc(ImplementAdjustedProgressActualCostAmountEtcReqDto reqDto){


      ImplementPrepareTargetBelongCycleDataComRespDto implementPrepareTargetBelongCycleDataComRespDto_1 =null;
AnalysisDataTypeCalcSceneComRespDto analysisDataTypeCalcSceneComRespDto_1 =null;
      //步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1891646_1
receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891621_1
receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891622_1
receptionServiceReq.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1891625_1
receptionServiceReq.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891623_1
receptionServiceReq.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1891632_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1891633_1
receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1891634_1
receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1891647_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1891637_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1891638_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1891630_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTaskId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-任务ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-归属周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleTypeCode(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-周期类型标识不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3执行修正进度值/实际值/费用等-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1891756_1
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1891755_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1891764_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1891757_1
    }

    /*D2查询评价模板周期模式配置参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行修正进度值/实际值/费用等-D2查询评价模板周期模式配置参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3执行修正进度值/实际值/费用等-D2查询评价模板周期模式配置参数-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行修正进度值/实际值/费用等-D2查询评价模板周期模式配置参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行修正进度值/实际值/费用等-D2查询评价模板周期模式配置参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D3准备目标归属周期数据(同体取小) - implementPrepareTargetBelongCycleDataCom
     ImplementPrepareTargetBelongCycleDataComRespDto implementPrepareTargetBelongCycleDataComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          ImplementPrepareTargetBelongCycleDataComReqDto implementPrepareTargetBelongCycleDataComReqDto=new ImplementPrepareTargetBelongCycleDataComReqDto();
  implementPrepareTargetBelongCycleDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1891649_1
implementPrepareTargetBelongCycleDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1891650_1
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      implementPrepareTargetBelongCycleDataComReqDto.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1891656_1
    }
if(reqDto!=null){
      implementPrepareTargetBelongCycleDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1891653_1
implementPrepareTargetBelongCycleDataComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1891751_1
implementPrepareTargetBelongCycleDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1891651_1
implementPrepareTargetBelongCycleDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1891652_1
implementPrepareTargetBelongCycleDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1891654_1
implementPrepareTargetBelongCycleDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1891655_1
    }

    /*D3准备目标归属周期数据(同体取小)[9424]   */
    Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getPeriodicModeTypeCode(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-周期模式类型编码不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaObjEntityId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaObjTypeCode(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getBelongToContentId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEntityId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-归属内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getCycleId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-归属周期ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getCycleTypeCode(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-周期类型标识不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaluationTemplateId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-冗余评价模板ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getSpaceId(),"D3执行修正进度值/实际值/费用等-D3准备目标归属周期数据(同体取小)-创建于空间ID不能为空",false);
      implementPrepareTargetBelongCycleDataComRespDto = targetCalcService.implementPrepareTargetBelongCycleDataCom(implementPrepareTargetBelongCycleDataComReqDto)/*vcase invoke isSameApp*/;


      implementPrepareTargetBelongCycleDataComRespDto_1 = implementPrepareTargetBelongCycleDataComRespDto;
           }

//步骤3: D4执行修正进度值/实际值/费用金额(公共) - implementAdjustedProgressActualCostAmountCom
     ImplementAdjustedProgressActualCostAmountComRespDto implementAdjustedProgressActualCostAmountComRespDto = null;
    ImplementAdjustedProgressActualCostAmountComReqDto implementAdjustedProgressActualCostAmountComReqDto=new ImplementAdjustedProgressActualCostAmountComReqDto();
  if(reqDto!=null){
      implementAdjustedProgressActualCostAmountComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891347_1
implementAdjustedProgressActualCostAmountComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891348_1
implementAdjustedProgressActualCostAmountComReqDto.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1891349_1
implementAdjustedProgressActualCostAmountComReqDto.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891350_1
    }

    /*D4执行修正进度值/实际值/费用金额(公共)[9862]   */

      implementAdjustedProgressActualCostAmountComRespDto = fwCalcEvaCalcClient.implementAdjustedProgressActualCostAmountCom(implementAdjustedProgressActualCostAmountComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: D4分析数据点计算场景(公共) - analysisDataTypeCalcSceneCom
     AnalysisDataTypeCalcSceneComRespDto analysisDataTypeCalcSceneComRespDto = null;
    if(implementAdjustedProgressActualCostAmountComRespDto !=null){
          AnalysisDataTypeCalcSceneComReqDto analysisDataTypeCalcSceneComReqDto=new AnalysisDataTypeCalcSceneComReqDto();
  if(implementAdjustedProgressActualCostAmountComRespDto!=null){
      analysisDataTypeCalcSceneComReqDto.setProgressValue(implementAdjustedProgressActualCostAmountComRespDto.getProgressValue());//SimpleFieldAssign//sourceId:1891343_1
analysisDataTypeCalcSceneComReqDto.setActualValue(implementAdjustedProgressActualCostAmountComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1891344_1
analysisDataTypeCalcSceneComReqDto.setBudgetDisburse(implementAdjustedProgressActualCostAmountComRespDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891345_1
    }

    /*D4分析数据点计算场景(公共)[9863]   */

      analysisDataTypeCalcSceneComRespDto = fwCalcEvaCalcClient.analysisDataTypeCalcSceneCom(analysisDataTypeCalcSceneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      analysisDataTypeCalcSceneComRespDto_1 = analysisDataTypeCalcSceneComRespDto;
           }

//步骤5: D4执行修正并计算目标标准数据(公共) - implementAdjustedAndCalcTargetStandardDataCom
     ImplementAdjustedAndCalcTargetStandardDataComRespDto implementAdjustedAndCalcTargetStandardDataComRespDto = null;
    if(analysisDataTypeCalcSceneComRespDto !=null){
          ImplementAdjustedAndCalcTargetStandardDataComReqDto implementAdjustedAndCalcTargetStandardDataComReqDto=new ImplementAdjustedAndCalcTargetStandardDataComReqDto();
  implementAdjustedAndCalcTargetStandardDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1932036_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1932037_1
if(analysisDataTypeCalcSceneComRespDto!=null){
      implementAdjustedAndCalcTargetStandardDataComReqDto.setApproveCalcScene(analysisDataTypeCalcSceneComRespDto.getApproveCalcScene());//SimpleFieldAssign//sourceId:1932043_1
    }
if(implementAdjustedProgressActualCostAmountComRespDto!=null){
      implementAdjustedAndCalcTargetStandardDataComReqDto.setProgressValue(implementAdjustedProgressActualCostAmountComRespDto.getProgressValue());//SimpleFieldAssign//sourceId:1932029_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setActualValue(implementAdjustedProgressActualCostAmountComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1932030_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setBudgetDisburse(implementAdjustedProgressActualCostAmountComRespDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1932032_1
    }
if(reqDto!=null){
      implementAdjustedAndCalcTargetStandardDataComReqDto.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1932031_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1932039_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1932033_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1932040_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1932034_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1932041_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932035_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1932038_1
    }
if(implementPrepareTargetBelongCycleDataComRespDto!=null){
      implementAdjustedAndCalcTargetStandardDataComReqDto.setParentSubMidCycleType(implementPrepareTargetBelongCycleDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932044_1
implementAdjustedAndCalcTargetStandardDataComReqDto.setCycleStartTime(implementPrepareTargetBelongCycleDataComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1932042_1
    }

    /*D4执行修正并计算目标标准数据(公共)[9959]   */
    Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getApproveCalcScene(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-审核的计算场景不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getEvaObjEntityId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getEvaObjTypeCode(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getParentSubMidCycleType(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getCycleId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-归属周期ID不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getCycleStartTime(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getCycleTypeCode(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getEntityId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getBelongToContentId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getThemeContentId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-主题内容ID不能为空",false);
Assert.isNull(implementAdjustedAndCalcTargetStandardDataComReqDto.getSpaceId(),"D3执行修正进度值/实际值/费用等-D4执行修正并计算目标标准数据(公共)-创建于空间ID不能为空",false);
      implementAdjustedAndCalcTargetStandardDataComRespDto = fwCalcEvaCalcClient.implementAdjustedAndCalcTargetStandardDataCom(implementAdjustedAndCalcTargetStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

ImplementAdjustedProgressActualCostAmountEtcRespDto retData = new ImplementAdjustedProgressActualCostAmountEtcRespDto();
  if(analysisDataTypeCalcSceneComRespDto_1!=null){
      retData.setApproveCalcScene(analysisDataTypeCalcSceneComRespDto_1.getApproveCalcScene());//SimpleFieldAssign//sourceId:2011227_1
    }
if(implementPrepareTargetBelongCycleDataComRespDto_1!=null){
      retData.setCycleStartTime(implementPrepareTargetBelongCycleDataComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2011232_1
    }




return retData;
  }
/**
   * D3统计目标内容数与完成数与完成率(公共)[9875]
   * gen by moon at 6/30/2024, 9:21:54 AM
   */
  @Trace(operationName = "D3统计目标内容数与完成数与完成率(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateCom(StatisticsTargetContentAndComAndComRateComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定：0  70898
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1896984_1_70898

    /*M3约定：0[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComNumField(),"D3统计目标内容数与完成数与完成率(公共)-M3约定：0-通用数值字段（整数型）不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



//virtualUsage 3-3-09批量查被评对象目标周期列表  70887
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    BatchQueryEvaObjTargetCycleReq batchQueryEvaObjTargetCycleReq=new BatchQueryEvaObjTargetCycleReq();
  if(reqDto!=null){
      batchQueryEvaObjTargetCycleReq.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1896721_1_70887
batchQueryEvaObjTargetCycleReq.setIsReached(reqDto.getIsReached());//SimpleFieldAssign//sourceId:1896722_1_70887
batchQueryEvaObjTargetCycleReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1897130_1_70887
    }

    /*3-3-09批量查被评对象目标周期列表[2335]   */
    Assert.isNull(batchQueryEvaObjTargetCycleReq.getIsReached(),"D3统计目标内容数与完成数与完成率(公共)-3-3-09批量查被评对象目标周期列表-目标是否达成不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleReq.getEvaluationTemplateId(),"D3统计目标内容数与完成数与完成率(公共)-3-3-09批量查被评对象目标周期列表-冗余评价模板ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryEvaObjTargetCycle(batchQueryEvaObjTargetCycleReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2统计数据集内容条数服务(公共)  70888
      CalculateContentAmountComRespDto calculateContentAmountComRespDto = null;
    CalculateContentAmountComReqDto calculateContentAmountComReqDto=new CalculateContentAmountComReqDto();
  if(reqDto!=null){
      calculateContentAmountComReqDto.setContentAmountList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1896726_1_70888
    }

    /*D2统计数据集内容条数服务(公共)[3386]   */

      calculateContentAmountComRespDto = fwCompStatisticalDataClient.calculateContentAmountCom(calculateContentAmountComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2统计数据集内容条数服务(公共)  70889
      CalculateContentAmountComRespDto calculateContentAmountComRespDto_2 = null;

          CalculateContentAmountComReqDto calculateContentAmountComReqDto_1=new CalculateContentAmountComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      calculateContentAmountComReqDto_1.setContentAmountList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1896726_1_70889
    }

    /*D2统计数据集内容条数服务(公共)[3386]   */

      calculateContentAmountComRespDto_2 = fwCompStatisticalDataClient.calculateContentAmountCom(calculateContentAmountComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((calculateContentAmountComRespDto!= null&& calculateContentAmountComRespDto.getCalcCount() > 0L)) {
        //if(D2统计目标内容数.统计数 大于 0)  70890

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1897116_1_70896
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("DEGREE_DECIMAL_POINT");//CUSTOM_CONVENTION//sourceId:1897117_1_70896
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1897118_1_70896
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1897115_1_70896
    }

    /*D2查达成度小数点规则[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3统计目标内容数与完成数与完成率(公共)-D2查达成度小数点规则-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3统计目标内容数与完成数与完成率(公共)-D2查达成度小数点规则-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3统计目标内容数与完成数与完成率(公共)-D2查达成度小数点规则-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3统计目标内容数与完成数与完成率(公共)-D2查达成度小数点规则-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:1897122_1_70897
queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("DECIMAL_DIGITS_LAST_RULES");//CUSTOM_CONVENTION//sourceId:1897123_1_70897
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1897124_1_70897
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1897121_1_70897
    }

    /*D2查小数最后一位规则[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3统计目标内容数与完成数与完成率(公共)-D2查小数最后一位规则-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjType(),"D3统计目标内容数与完成数与完成率(公共)-D2查小数最后一位规则-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3统计目标内容数与完成数与完成率(公共)-D2查小数最后一位规则-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3统计目标内容数与完成数与完成率(公共)-D2查小数最后一位规则-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



CalculateDivisionOfTwoNumComRespDto calculateDivisionOfTwoNumComRespDto = null;
// TODO: 2024/6/26
          CalculateDivisionOfTwoNumComReqDto calculateDivisionOfTwoNumComReqDto=new CalculateDivisionOfTwoNumComReqDto();
  calculateDivisionOfTwoNumComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:1896731_1_70891
  if(calculateContentAmountComRespDto_2!=null){
      calculateDivisionOfTwoNumComReqDto.setCalcPara1(calculateContentAmountComRespDto_2.getCalcCount()!=null?Double.valueOf(calculateContentAmountComRespDto_2.getCalcCount()):null);//SimpleFieldAssign//sourceId:1896728_1_70891
    }
if(calculateContentAmountComRespDto!=null){
      calculateDivisionOfTwoNumComReqDto.setCalcPara2(calculateContentAmountComRespDto.getCalcCount()!=null?Double.valueOf(calculateContentAmountComRespDto.getCalcCount()):null);//SimpleFieldAssign//sourceId:1896729_1_70891
    }
if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      calculateDivisionOfTwoNumComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1896732_1_70891
    }

    /*D4-计算两个数相除服务(公共)[4841]   */
    Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara1(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数相除服务(公共)-计算入参1不能为空",false);
Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara2(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数相除服务(公共)-计算入参2不能为空",false);
Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalPointRules(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数相除服务(公共)-小数点规则不能为空",false);
Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalDigitsLastRules(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数相除服务(公共)-小数最后一位规则不能为空",false);
      calculateDivisionOfTwoNumComRespDto = fwCalcCalculationRulesClient.calculateDivisionOfTwoNumCom(calculateDivisionOfTwoNumComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




CalculateMultiplyTwoValuesComRespDto calculateMultiplyTwoValuesComRespDto = null;
    if(calculateDivisionOfTwoNumComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto_2 !=null){
          CalculateMultiplyTwoValuesComReqDto calculateMultiplyTwoValuesComReqDto=new CalculateMultiplyTwoValuesComReqDto();
  calculateMultiplyTwoValuesComReqDto.setComFloatField2(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1900596_1_70988
if(calculateDivisionOfTwoNumComRespDto!=null){
      calculateMultiplyTwoValuesComReqDto.setComFloatField1(calculateDivisionOfTwoNumComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1900595_1_70988
    }
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      calculateMultiplyTwoValuesComReqDto.setDecimalPointRules(queryConfItemMatchAnswerDetailComRespDto.getEndValue()!=null?Long.valueOf(queryConfItemMatchAnswerDetailComRespDto.getEndValue()):null);//SimpleFieldAssign//sourceId:1900598_1_70988
    }
if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      calculateMultiplyTwoValuesComReqDto.setDecimalDigitsLastRules(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1900599_1_70988
    }

    /*D4-计算两个数值相乘服务(公共)[5443]   */
    Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField1(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数值相乘服务(公共)-通用数值字段1（小数型）不能为空",false);
Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField2(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数值相乘服务(公共)-通用数值字段2（小数型）不能为空",false);
Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalPointRules(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数值相乘服务(公共)-小数点规则不能为空",false);
Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalDigitsLastRules(),"D3统计目标内容数与完成数与完成率(公共)-D4-计算两个数值相乘服务(公共)-小数最后一位规则不能为空",false);
      calculateMultiplyTwoValuesComRespDto = fwCalcInterfaceModeClient.calculateMultiplyTwoValuesCom(calculateMultiplyTwoValuesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(calculateContentAmountComRespDto !=null&&calculateContentAmountComRespDto_2 !=null&&calculateDivisionOfTwoNumComRespDto !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(calculateContentAmountComRespDto!=null){
      receptionServiceReq_1.setTargetContentNumber(calculateContentAmountComRespDto.getCalcCount()!=null?String.valueOf(calculateContentAmountComRespDto.getCalcCount()):"");//SimpleFieldAssign//sourceId:1896694_1_70894
    }
if(calculateContentAmountComRespDto_2!=null){
      receptionServiceReq_1.setTargetCompletionNum(calculateContentAmountComRespDto_2.getCalcCount()!=null?Double.valueOf(calculateContentAmountComRespDto_2.getCalcCount()):null);//SimpleFieldAssign//sourceId:1896692_1_70894
    }
if(calculateMultiplyTwoValuesComRespDto!=null){
      receptionServiceReq_1.setTargetCompletionRate(calculateMultiplyTwoValuesComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1896693_1_70894
    }

    /*M3接收出参：目标内容数与完成数与完成率[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetContentNumber(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标内容数不能为空",false);
Assert.isNull(receptionServiceReq_1.getTargetCompletionNum(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标完成数不能为空",false);
Assert.isNull(receptionServiceReq_1.getTargetCompletionRate(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标完成率不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((calculateContentAmountComRespDto!= null&& calculateContentAmountComRespDto.getCalcCount() == 0L)){
       //elseif(D2统计目标内容数.统计数 等于 0)  70892

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    if(calculateContentAmountComRespDto !=null&&calculateContentAmountComRespDto_2 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(calculateContentAmountComRespDto!=null){
      receptionServiceReq_2.setTargetContentNumber(calculateContentAmountComRespDto.getCalcCount()!=null?String.valueOf(calculateContentAmountComRespDto.getCalcCount()):"");//SimpleFieldAssign//sourceId:1896694_1_70893
    }
if(calculateContentAmountComRespDto_2!=null){
      receptionServiceReq_2.setTargetCompletionNum(calculateContentAmountComRespDto_2.getCalcCount()!=null?Double.valueOf(calculateContentAmountComRespDto_2.getCalcCount()):null);//SimpleFieldAssign//sourceId:1896692_1_70893
    }
if(receptionServiceRes!=null){
      receptionServiceReq_2.setTargetCompletionRate(receptionServiceRes.getComNumField()!=null?Double.valueOf(receptionServiceRes.getComNumField()):null);//SimpleFieldAssign//sourceId:1896693_1_70893
    }

    /*M3接收出参：目标内容数与完成数与完成率[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTargetContentNumber(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标内容数不能为空",false);
Assert.isNull(receptionServiceReq_2.getTargetCompletionNum(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标完成数不能为空",false);
Assert.isNull(receptionServiceReq_2.getTargetCompletionRate(),"D3统计目标内容数与完成数与完成率(公共)-M3接收出参：目标内容数与完成数与完成率-目标完成率不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
    }
StatisticsTargetContentAndComAndComRateComRespDto retData = new StatisticsTargetContentAndComAndComRateComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTargetContentNumber(receptionServiceRes_3.getTargetContentNumber());//SimpleFieldAssign//sourceId:1897131_1
retData.setTargetCompletionNum(receptionServiceRes_3.getTargetCompletionNum());//SimpleFieldAssign//sourceId:1897132_1
retData.setTargetCompletionRate(receptionServiceRes_3.getTargetCompletionRate());//SimpleFieldAssign//sourceId:1897133_1
    }




return retData;
  }
/**
   * D3执行分析目标分类一级or末级(公共)[9878]
   * gen by moon at 7/2/2024, 3:46:53 AM
   */
  @Trace(operationName = "D3执行分析目标分类一级or末级(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyzeTargetClassFirstOrLastLevelComRespDto implementAnalyzeTargetClassFirstOrLastLevelCom(ImplementAnalyzeTargetClassFirstOrLastLevelComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getIsLastCategory() !=null && reqDto.getIsLastCategory().equals("TRUE")&&reqDto!= null&& reqDto.getTargetContentLevelNumber() == null )) {
        //if((D3执行分析目标分类一级or末级(公共).是否末级目标分类 等于 是 and D3执行分析目标分类一级or末级(公共).目标内容层级 值等于空 ))  70966

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setCorrelationLastTargetCatId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:1900382_1_70976
    }

    /*M3接收一、二目标分类ID或末级目标分类ID[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&& reqDto.getTargetContentLevelNumber() == 1L&&reqDto!= null&& reqDto.getIsLastCategory() == null )){
       //elseif((D3执行分析目标分类一级or末级(公共).目标内容层级 等于 1 and D3执行分析目标分类一级or末级(公共).是否末级目标分类 值等于空 ))  70968

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setOneLevelCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:1900381_1_70977
    }

    /*M3接收一、二目标分类ID或末级目标分类ID[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
else if((reqDto!= null&& reqDto.getTargetContentLevelNumber() == 2L&&reqDto!= null&&  reqDto.getIsLastCategory() !=null && reqDto.getIsLastCategory().equals("FALSE"))){
       //elseif((D3执行分析目标分类一级or末级(公共).目标内容层级 等于 2 and D3执行分析目标分类一级or末级(公共).是否末级目标分类 等于 否))  71132

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setTwoLevelCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:1911113_1_71133
    }

    /*M3接收一、二目标分类ID或末级目标分类ID[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
    }
else{
       //else  70969

//异常结束 70975
      throw new BizException("3300T10000468","对不起，是否末级目标分类、目标分类层级入参错误～",false);
    }
ImplementAnalyzeTargetClassFirstOrLastLevelComRespDto retData = new ImplementAnalyzeTargetClassFirstOrLastLevelComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setOneLevelCategoryId(receptionServiceRes_1.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1900387_1
retData.setTwoLevelCategoryId(receptionServiceRes_1.getTwoLevelCategoryId());//SimpleFieldAssign//sourceId:1911115_1
retData.setCorrelationLastTargetCatId(receptionServiceRes_1.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:1900388_1
    }




return retData;
  }
/**
   * D3-查树根节点信息详情(公共)[3754]
   * gen by moon at 6/29/2024, 12:44:16 PM
   */
  @Trace(operationName = "D3-查树根节点信息详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySearchTreeRootNodeInfoDetailComRespDto querySearchTreeRootNodeInfoDetailCom(QuerySearchTreeRootNodeInfoDetailComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getDashboradPrimaryDeptId() != null &&reqDto!= null&& reqDto.getDashboradBasicDeptId() == null &&reqDto!= null&& reqDto.getOriginalRoleMemberId() == null )) {
        //if((D3-查树根节点信息详情(公共).大屏归属中层部门ID 值不等于空  and D3-查树根节点信息详情(公共).大屏归属基层部门ID 值等于空  and D3-查树根节点信息详情(公共).身份人员ID 值等于空 ))  71003

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1902283_1_71007
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:1901412_1_71007
queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1901416_1_71007
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1901415_1_71007
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1901437_1_71007
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1901421_1_71007
queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1901417_1_71007
queryEvaObjTargetCycleDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1901419_1_71007
    }

    /*3-3-09查部门目标任务书被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-3-3-09查部门目标任务书被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-3-3-09查部门目标任务书被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-查树根节点信息详情(公共)-3-3-09查部门目标任务书被评对象目标周期详情-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      receptionServiceReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1902554_1_71018
receptionServiceReq.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1902555_1_71018
receptionServiceReq.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1902556_1_71018
    }

    /*M3接收树信息[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象类型编码不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
//if((omsEvaluationObjectTargetCycle == null )) {
//        //if(3-3-09查部门目标任务书被评对象目标周期详情.出参 值等于空 )  71011
//
////异常结束 71012
//      throw new BizException("3300T10000471","对不起，找不到部门目标任务书根节点ID",false);
//      }
      }
else if((reqDto!= null&& reqDto.getDashboradPrimaryDeptId() == null &&reqDto!= null&& reqDto.getDashboradBasicDeptId() != null &&reqDto!= null&& reqDto.getOriginalRoleMemberId() == null )){
       //elseif((D3-查树根节点信息详情(公共).大屏归属中层部门ID 值等于空  and D3-查树根节点信息详情(公共).大屏归属基层部门ID 值不等于空  and D3-查树根节点信息详情(公共).身份人员ID 值等于空 ))  71004

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode("OKR_SUBJECT_DEPT");//sourceId:1902284_1_71009
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getDashboradBasicDeptId());//SimpleFieldAssign//sourceId:1902251_1_71009
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1902253_1_71009
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1902254_1_71009
queryEvaObjTargetCycleDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1902255_1_71009
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1902259_1_71009
queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1902256_1_71009
queryEvaObjTargetCycleDetailReq_1.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1902257_1_71009
    }

    /*3-3-09查OKR部门根节点被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-3-3-09查OKR部门根节点被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-3-3-09查OKR部门根节点被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-查树根节点信息详情(公共)-3-3-09查OKR部门根节点被评对象目标周期详情-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(omsEvaluationObjectTargetCycle_2!=null){
      receptionServiceReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1902554_1_71019
receptionServiceReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle_2.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1902555_1_71019
receptionServiceReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1902556_1_71019
    }

    /*M3接收树信息[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEvaObjTargetCycleId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象类型编码不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
//if((omsEvaluationObjectTargetCycle_2 == null )) {
//        //if(3-3-09查OKR部门根节点被评对象目标周期详情.出参 值等于空 )  71016
//
////异常结束 71017
//      throw new BizException("3300T10000472","对不起，找不到OKR部门根节点ID～！",false);
//      }
    }
else if((reqDto!= null&& reqDto.getOriginalRoleMemberId() != null &&reqDto!= null&& reqDto.getDashboradPrimaryDeptId() == null &&reqDto!= null&& reqDto.getDashboradBasicDeptId() == null )){
       //elseif((D3-查树根节点信息详情(公共).身份人员ID 值不等于空  and D3-查树根节点信息详情(公共).大屏归属中层部门ID 值等于空  and D3-查树根节点信息详情(公共).大屏归属基层部门ID 值等于空 ))  71032

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode("OKR_SUBJECT_PERSONAL");//sourceId:1904299_1_71033
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1904298_1_71033
queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1904300_1_71033
queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1904301_1_71033
queryEvaObjTargetCycleDetailReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1904302_1_71033
queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1904303_1_71033
queryEvaObjTargetCycleDetailReq_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1904304_1_71033
queryEvaObjTargetCycleDetailReq_2.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1904305_1_71033
    }

    /*3-3-09查OKR个人根节点被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-3-3-09查OKR个人根节点被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-3-3-09查OKR个人根节点被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(),"D3-查树根节点信息详情(公共)-3-3-09查OKR个人根节点被评对象目标周期详情-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    if(omsEvaluationObjectTargetCycle_4 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(omsEvaluationObjectTargetCycle_4!=null){
      receptionServiceReq_2.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_4.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1902554_1_71036
receptionServiceReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle_4.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1902555_1_71036
receptionServiceReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_4.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1902556_1_71036
    }

    /*M3接收树信息[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getEvaObjTargetCycleId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq_2.getEvaObjEntityId(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq_2.getEvaObjTypeCode(),"D3-查树根节点信息详情(公共)-M3接收树信息-被评对象类型编码不能为空",false);
      receptionServiceRes_3 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
else{
       //else  71005

//异常结束 71006
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
QuerySearchTreeRootNodeInfoDetailComRespDto retData = new QuerySearchTreeRootNodeInfoDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1902576_1
retData.setEvaObjEntityId(receptionServiceRes_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1902577_1
retData.setEvaObjTypeCode(receptionServiceRes_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1902578_1
    }




return retData;
  }
/**
   * D3执行父子中查目标归属周期(公共)[9879]
   * gen by moon at 6/27/2024, 6:31:13 PM
   */
  @Trace(operationName = "D3执行父子中查目标归属周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFatherSonSearchTargetcycleComRespDto implementFatherSonSearchTargetcycleCom(ImplementFatherSonSearchTargetcycleComReqDto reqDto){


      OmsTargetAttributionCycle omsTargetAttributionCycle_1 =null;
if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))) {
        //if((D3执行父子中查目标归属周期(公共).父子中过程周期类型 等于 父周期 or D3执行父子中查目标归属周期(公共).父子中过程周期类型 等于 中期))  70991

OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq=new QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq();
  if(reqDto!=null){
      queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1900648_1_70995
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1900649_1_70995
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1900746_1_70995
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1900752_1_70995
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1900653_1_70995
    }

    /*3-3-09-07通过父子中查询目标归属周期[9578]   */
    Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getEvaObjEntityId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getEvaObjTypeCode(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getParentSubMidCycleType(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getBelongToContentId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq.getEvaluationTemplateId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-冗余评价模板ID不能为空",false);
      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByGeStartAndLeEndTimeDetail(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetAttributionCycle_1 = omsTargetAttributionCycle;
if((omsTargetAttributionCycle!= null&& omsTargetAttributionCycle.getTargetAttributionCycleId() == null )) {
        //if(3-3-09-07通过父子中查询目标归属周期.目标归属周期ID 值等于空 )  70996

//异常结束 70997
      throw new BizException("3300T10000470","对不起，在目标分类下统计目标内容数，找不到目标归属周期！～",false);
      }
      }
else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE"))){
       //elseif(D3执行父子中查目标归属周期(公共).父子中过程周期类型 等于 子周期)  70992

OmsTargetAttributionCycle omsTargetAttributionCycle_2 = null;
    QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1=new QueryTargetBelongCycleByGeStartAndLeEndTimeDetailReq();
  if(reqDto!=null){
      queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1900648_1_70998
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1900649_1_70998
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1900746_1_70998
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1900650_1_70998
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1900752_1_70998
queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1900653_1_70998
    }

    /*3-3-09-07通过父子中查询目标归属周期[9578]   */
    Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.getEvaObjEntityId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.getEvaObjTypeCode(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.getParentSubMidCycleType(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.getBelongToContentId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1.getEvaluationTemplateId(),"D3执行父子中查目标归属周期(公共)-3-3-09-07通过父子中查询目标归属周期-冗余评价模板ID不能为空",false);
      omsTargetAttributionCycle_2 = mOmsTargetAttributionCycleService.queryTargetBelongCycleByGeStartAndLeEndTimeDetail(queryTargetBelongCycleByGeStartAndLeEndTimeDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetAttributionCycle_1 = omsTargetAttributionCycle_2;
if((omsTargetAttributionCycle_2!= null&& omsTargetAttributionCycle_2.getTargetAttributionCycleId() == null )) {
        //if(3-3-09-07通过父子中查询目标归属周期.目标归属周期ID 值等于空 )  70999

//异常结束 71000
      throw new BizException("3300T10000470","对不起，在目标分类下统计目标内容数，找不到目标归属周期！～",false);
      }
    }
else{
       //else  70993

//异常结束 70994
      throw new BizException("3300T10000469","对不起，不能入参父子中之外的枚举值～",false);
    }
ImplementFatherSonSearchTargetcycleComRespDto retData = new ImplementFatherSonSearchTargetcycleComRespDto();
  if(omsTargetAttributionCycle_1!=null){
      retData.setTargetAttributionCycleId(omsTargetAttributionCycle_1.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1900778_1
retData.setLastEvaObjTargetCycleId(omsTargetAttributionCycle_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1900779_1
retData.setPreviousCycleId(omsTargetAttributionCycle_1.getPreviousCycleId());//SimpleFieldAssign//sourceId:1900780_1
retData.setCycleId(omsTargetAttributionCycle_1.getCycleId());//SimpleFieldAssign//sourceId:1900781_1
retData.setCycleStartTime(omsTargetAttributionCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1900782_1
retData.setCycleEndTime(omsTargetAttributionCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1900783_1
retData.setCycleTypeCode(omsTargetAttributionCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1900784_1
retData.setCycleTypeInstanceCode(omsTargetAttributionCycle_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1900785_1
retData.setParentSubMidCycleType(omsTargetAttributionCycle_1.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1900786_1
retData.setIsWorkCycleData(omsTargetAttributionCycle_1.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1900787_1
retData.setWorkCycleUpdateSlice(omsTargetAttributionCycle_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1900788_1
retData.setStandardDataCalcCycleModel(omsTargetAttributionCycle_1.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1900789_1
retData.setEvaObjEntityId(omsTargetAttributionCycle_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1900934_1
retData.setEvaObjTypeCode(omsTargetAttributionCycle_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1900935_1
retData.setEvaObjTargetCycleId(omsTargetAttributionCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1900825_1
retData.setTableTypeCode(omsTargetAttributionCycle_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1900826_1
retData.setEntityId(omsTargetAttributionCycle_1.getEntityId());//SimpleFieldAssign//sourceId:1900827_1
retData.setBelongToContentTypeCode(omsTargetAttributionCycle_1.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1900790_1
retData.setBelongToContentId(omsTargetAttributionCycle_1.getBelongToContentId());//SimpleFieldAssign//sourceId:1900791_1
retData.setPersonLiableTypeCode(omsTargetAttributionCycle_1.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1900792_1
retData.setPersonLiableObjId(omsTargetAttributionCycle_1.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1900793_1
retData.setBizRoleObjId(omsTargetAttributionCycle_1.getBizRoleObjId());//SimpleFieldAssign//sourceId:1900794_1
retData.setBizRoleObjCode(omsTargetAttributionCycle_1.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1900795_1
retData.setBizRoleObjName(omsTargetAttributionCycle_1.getBizRoleObjName());//SimpleFieldAssign//sourceId:1900796_1
    }




return retData;
  }
/**
   * D3分析身份人员归属内容表主键(公共)[9899]
   * gen by moon at 6/30/2024, 12:45:43 AM
   */
  @Trace(operationName = "D3分析身份人员归属内容表主键(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisOriginalRoleMembErentityIdComRespDto analysisOriginalRoleMembErentityIdCom(AnalysisOriginalRoleMembErentityIdComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定：归属内容表类型编码（被评对象目标周期表与身份人员表）  71115
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//CUSTOM_CONVENTION//sourceId:1910314_1_71115
receptionServiceReq.setCustomField2("OMS_FRAMEWORK_ORIGINAL_ROLE_MEMBER");//CUSTOM_CONVENTION//sourceId:1910315_1_71115

    /*M3约定：归属内容表类型编码（被评对象目标周期表与身份人员表）[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析身份人员归属内容表主键(公共)-M3约定：归属内容表类型编码（被评对象目标周期表与身份人员表）-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析身份人员归属内容表主键(公共)-M3约定：归属内容表类型编码（被评对象目标周期表与身份人员表）-自定义字段2不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getBelongToPersonalIdentityRoleCode() !=null && reqDto.getBelongToPersonalIdentityRoleCode().equals("PRINCIPAL"))) {
        //if(D3分析身份人员归属内容表主键(公共).数据归属对象角色编码 等于 负责人)  71099

if((reqDto!= null&& reqDto.getEvaObjTargetCycleId() != null )) {
        //if(D3分析身份人员归属内容表主键(公共).被评对象目标周期ID 值不等于空 )  71103

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTableTypeCode(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1910310_1_71116
    }
if(reqDto!=null){
      receptionServiceReq_1.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1910311_1_71116
    }

    /*M3接收出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTableTypeCode(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq_1.getEntityId(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表主键ID不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getEvaObjTargetCycleId() == null )){
       //elseif(D3分析身份人员归属内容表主键(公共).被评对象目标周期ID 值等于空 )  71104

//异常结束 71114
      throw new BizException("3300T10000473","对不起，找不到OKR个人根节点ID～！",false);
    }
      }
else if((reqDto!= null&&  reqDto.getBelongToPersonalIdentityRoleCode() !=null && reqDto.getBelongToPersonalIdentityRoleCode().equals("DIRECTOR"))){
       //elseif(D3分析身份人员归属内容表主键(公共).数据归属对象角色编码 等于 主管)  71100

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setTableTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1910310_1_71117
    }
if(reqDto!=null){
      receptionServiceReq_2.setEntityId(reqDto.getDashboradDirectorOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1910311_1_71117
    }

    /*M3接收出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTableTypeCode(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq_2.getEntityId(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表主键ID不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getBelongToPersonalIdentityRoleCode() !=null && reqDto.getBelongToPersonalIdentityRoleCode().equals("DEPT_LEADER"))){
       //elseif(D3分析身份人员归属内容表主键(公共).数据归属对象角色编码 等于 分管领导)  71101

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setTableTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1910310_1_71118
    }
if(reqDto!=null){
      receptionServiceReq_3.setEntityId(reqDto.getDashboradDeptLeaderOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1910311_1_71118
    }

    /*M3接收出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTableTypeCode(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq_3.getEntityId(),"D3分析身份人员归属内容表主键(公共)-M3接收出参-归属内容表主键ID不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }

else {
       //else  71120

//异常结束 71121
      throw new BizException("C10100475","对不起，找不到员工身份角色（统计员工目标完成数）~",false);
}
AnalysisOriginalRoleMembErentityIdComRespDto retData = new AnalysisOriginalRoleMembErentityIdComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTableTypeCode(receptionServiceRes_3.getTableTypeCode());//SimpleFieldAssign//sourceId:1910318_1
retData.setEntityId(receptionServiceRes_3.getEntityId());//SimpleFieldAssign//sourceId:1910319_1
    }




return retData;
  }
/**
   * D3执行二级目标分类及指标统计数据(公共)[9904]
   * gen by moon at 6/30/2024, 10:11:53 PM
   */
  @Trace(operationName = "D3执行二级目标分类及指标统计数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTwoTargetCategoryAndObjectiveTotalDataComRespDto implementTwoTargetCategoryAndObjectiveTotalDataCom(ImplementTwoTargetCategoryAndObjectiveTotalDataComReqDto reqDto){


      StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto_1 =null;
//virtualUsage 3-3-02查目标分类列表  71134
      List<OmsTargetCategory> listOmsTargetCategory =new ArrayList<>();
    QueryTargetCatListReq queryTargetCatListReq=new QueryTargetCatListReq();
  queryTargetCatListReq.setIsArchive("FALSE");//sourceId:1911409_1_71134
if(reqDto!=null){
      queryTargetCatListReq.setParentTtargetCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:1911407_1_71134
queryTargetCatListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1911408_1_71134
    }

    /*3-3-02查目标分类列表[2592]   */
    Assert.isNull(queryTargetCatListReq.getParentTtargetCategoryId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-02查目标分类列表-归属父级目标分类ID不能为空",false);
Assert.isNull(queryTargetCatListReq.getEvaluationTemplateId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-02查目标分类列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatListReq.getIsArchive(),"D3执行二级目标分类及指标统计数据(公共)-3-3-02查目标分类列表-是否存档不能为空",false);
      listOmsTargetCategory = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsTargetCategory!= null&&  listOmsTargetCategory !=null && listOmsTargetCategory.size()>0)) {
        //if(3-3-02查目标分类列表.设置建设任务列表数据集条数 大于 0)  71135

if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))) {
        //if((D3执行二级目标分类及指标统计数据(公共).父子中过程周期类型 等于 父周期 or D3执行二级目标分类及指标统计数据(公共).父子中过程周期类型 等于 中期))  71137

List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    if(listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&& listOmsTargetCategory.size()>0 ){
        BatchQueryTargetBelongCycleByLastTargetCatIdReq batchQueryTargetBelongCycleByLastTargetCatIdReq=new BatchQueryTargetBelongCycleByLastTargetCatIdReq();
  if(listOmsTargetCategory!= null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&&  listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)){
      batchQueryTargetBelongCycleByLastTargetCatIdReq.setTargetBelongCycleList(listOmsTargetCategory.stream().map(item->item.getTargetCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1912330_1_71162
    }
if(reqDto!=null){
      batchQueryTargetBelongCycleByLastTargetCatIdReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1912331_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1912332_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1912334_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1912335_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setTargetContentLevelNumber(reqDto.getTargetContentLevelNumber());//SimpleFieldAssign//sourceId:1912337_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:1912338_1_71162
batchQueryTargetBelongCycleByLastTargetCatIdReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1912339_1_71162
    }

    /*3-3-09-07批量查询目标归属周期by末级目标分类[9906]   */
    Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getEvaObjEntityId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getEvaObjTypeCode(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-主树被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getParentSubMidCycleType(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-父子中过程周期类型不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getTargetCycleId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-目标周期ID不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getBelongToContentTypeCode(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-数据归属内容表类型编码不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getTargetContentLevelNumber(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-目标内容层级不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getIsLastObjective(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-是否末级指标不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq.getEvaluationTemplateId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-冗余评价模板ID不能为空",false);
      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.batchQueryTargetBelongCycleByLastTargetCatId(batchQueryTargetBelongCycleByLastTargetCatIdReq)/*vcase invoke 本地 method 方法调用;*/;



           }
StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto = null;
    if(listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&& listOmsTargetAttributionCycle.size()>0 ){
          StatisticsTargetContentAndComAndComRateComReqDto statisticsTargetContentAndComAndComRateComReqDto=new StatisticsTargetContentAndComAndComRateComReqDto();
  statisticsTargetContentAndComAndComRateComReqDto.setIsReached("TRUE");//sourceId:1911387_1_71141
if(listOmsTargetAttributionCycle!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&&  listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)){
      statisticsTargetContentAndComAndComRateComReqDto.setEvaObjTargetCycleList(listOmsTargetAttributionCycle.stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1911386_1_71141
    }
if(reqDto!=null){
      statisticsTargetContentAndComAndComRateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1911388_1_71141
    }

    /*D3统计目标内容数与完成数与完成率(公共)[9875]   */
    Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto.getIsReached(),"D3执行二级目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-目标是否达成不能为空",false);
Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto.getEvaluationTemplateId(),"D3执行二级目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-冗余评价模板ID不能为空",false);
      statisticsTargetContentAndComAndComRateComRespDto = statisticsTargetContentAndComAndComRateCom(statisticsTargetContentAndComAndComRateComReqDto)/*vcase invoke 同服务,同domain*/;


      statisticsTargetContentAndComAndComRateComRespDto_1 = statisticsTargetContentAndComAndComRateComRespDto;
           }
      }
else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE"))){
       //elseif(D3执行二级目标分类及指标统计数据(公共).父子中过程周期类型 等于 子周期)  71138

List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle_2 =new ArrayList<>();
    if(listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&& listOmsTargetCategory.size()>0 ){
          BatchQueryTargetBelongCycleByLastTargetCatIdReq batchQueryTargetBelongCycleByLastTargetCatIdReq_1=new BatchQueryTargetBelongCycleByLastTargetCatIdReq();
  if(listOmsTargetCategory!= null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&&  listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)){
      batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setTargetBelongCycleList(listOmsTargetCategory.stream().map(item->item.getTargetCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1912330_1_71163
    }
if(reqDto!=null){
      batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1912331_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1912332_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1912334_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setTargetCycleId(reqDto.getTargetCycleId());//SimpleFieldAssign//sourceId:1912333_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1912335_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setTargetContentLevelNumber(reqDto.getTargetContentLevelNumber());//SimpleFieldAssign//sourceId:1912337_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:1912338_1_71163
batchQueryTargetBelongCycleByLastTargetCatIdReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1912339_1_71163
    }

    /*3-3-09-07批量查询目标归属周期by末级目标分类[9906]   */
    Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getEvaObjEntityId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getEvaObjTypeCode(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-主树被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getParentSubMidCycleType(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-父子中过程周期类型不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getTargetCycleId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-目标周期ID不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getBelongToContentTypeCode(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-数据归属内容表类型编码不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getTargetContentLevelNumber(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-目标内容层级不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getIsLastObjective(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-是否末级指标不能为空",false);
//Assert.isNull(batchQueryTargetBelongCycleByLastTargetCatIdReq_1.getEvaluationTemplateId(),"D3执行二级目标分类及指标统计数据(公共)-3-3-09-07批量查询目标归属周期by末级目标分类-冗余评价模板ID不能为空",false);
      listOmsTargetAttributionCycle_2 = mOmsTargetAttributionCycleService.batchQueryTargetBelongCycleByLastTargetCatId(batchQueryTargetBelongCycleByLastTargetCatIdReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
StatisticsTargetContentAndComAndComRateComRespDto statisticsTargetContentAndComAndComRateComRespDto_2 = null;
    if(listOmsTargetAttributionCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_2)&& listOmsTargetAttributionCycle_2.size()>0 ){
          StatisticsTargetContentAndComAndComRateComReqDto statisticsTargetContentAndComAndComRateComReqDto_1=new StatisticsTargetContentAndComAndComRateComReqDto();
  statisticsTargetContentAndComAndComRateComReqDto_1.setIsReached("TRUE");//sourceId:1911387_1_71142
if(listOmsTargetAttributionCycle_2!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_2)&&  listOmsTargetAttributionCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_2)){
      statisticsTargetContentAndComAndComRateComReqDto_1.setEvaObjTargetCycleList(listOmsTargetAttributionCycle_2.stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1911386_1_71142
    }
if(reqDto!=null){
      statisticsTargetContentAndComAndComRateComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1911388_1_71142
    }

    /*D3统计目标内容数与完成数与完成率(公共)[9875]   */
    Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto_1.getIsReached(),"D3执行二级目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-目标是否达成不能为空",false);
Assert.isNull(statisticsTargetContentAndComAndComRateComReqDto_1.getEvaluationTemplateId(),"D3执行二级目标分类及指标统计数据(公共)-D3统计目标内容数与完成数与完成率(公共)-冗余评价模板ID不能为空",false);
      statisticsTargetContentAndComAndComRateComRespDto_2 = statisticsTargetContentAndComAndComRateCom(statisticsTargetContentAndComAndComRateComReqDto_1)/*vcase invoke 同服务,同domain*/;


      statisticsTargetContentAndComAndComRateComRespDto_1 = statisticsTargetContentAndComAndComRateComRespDto_2;
           }
    }
      }
ImplementTwoTargetCategoryAndObjectiveTotalDataComRespDto retData = new ImplementTwoTargetCategoryAndObjectiveTotalDataComRespDto();
  if(statisticsTargetContentAndComAndComRateComRespDto_1!=null){
      retData.setTargetContentNumber(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetContentNumber());//SimpleFieldAssign//sourceId:1911440_1
retData.setTargetCompletionNum(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetCompletionNum());//SimpleFieldAssign//sourceId:1911441_1
retData.setTargetCompletionRate(statisticsTargetContentAndComAndComRateComRespDto_1.getTargetCompletionRate());//SimpleFieldAssign//sourceId:1911442_1
    }




return retData;
  }
/**
   * D3分析二级目标分类下指标数据点范围(公共)[9905]
   * gen by moon at 6/30/2024, 9:22:53 AM
   */
  @Trace(operationName = "D3分析二级目标分类下指标数据点范围(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisTwoTargetCategoryContentDataComRespDto analysisTwoTargetCategoryContentDataCom(AnalysisTwoTargetCategoryContentDataComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getOneLevelCategoryId() != null ||reqDto!= null&& reqDto.getCorrelationLastTargetCatId() != null )&&(reqDto!= null&& reqDto.getTwoLevelCategoryId() == null )) {
        //if((D3分析二级目标分类下指标数据点范围(公共).冗余标准数据一级目标分类ID 值不等于空  or D3分析二级目标分类下指标数据点范围(公共).冗余标准数据末级目标分类ID 值不等于空 ) and D3分析二级目标分类下指标数据点范围(公共).冗余标准数据二级目标分类ID 值等于空 )  71145

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOneTargetContentNumber(reqDto.getOneTargetContentNumber());//SimpleFieldAssign//sourceId:1912090_1_71147
receptionServiceReq.setOneTargetCompletionNum(reqDto.getOneTargetCompletionNum());//SimpleFieldAssign//sourceId:1912091_1_71147
receptionServiceReq.setOneTargetCompletionRate(reqDto.getOneTargetCompletionRate());//SimpleFieldAssign//sourceId:1912092_1_71147
receptionServiceReq.setLastTargetContentNumber(reqDto.getLastTargetContentNumber());//SimpleFieldAssign//sourceId:1912087_1_71147
receptionServiceReq.setLastTargetCompletionNum(reqDto.getLastTargetCompletionNum());//SimpleFieldAssign//sourceId:1912088_1_71147
receptionServiceReq.setLastTargetCompletionRate(reqDto.getLastTargetCompletionRate());//SimpleFieldAssign//sourceId:1912089_1_71147
    }

    /*M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOneTargetContentNumber(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标内容数不能为空",false);
Assert.isNull(receptionServiceReq.getOneTargetCompletionNum(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标完成数不能为空",false);
Assert.isNull(receptionServiceReq.getOneTargetCompletionRate(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标完成率不能为空",false);
Assert.isNull(receptionServiceReq.getLastTargetContentNumber(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标内容数不能为空",false);
Assert.isNull(receptionServiceReq.getLastTargetCompletionNum(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标完成数不能为空",false);
Assert.isNull(receptionServiceReq.getLastTargetCompletionRate(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标完成率不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&& reqDto.getOneLevelCategoryId() == null &&reqDto!= null&& reqDto.getCorrelationLastTargetCatId() == null &&reqDto!= null&& reqDto.getTwoLevelCategoryId() != null )){
       //elseif((D3分析二级目标分类下指标数据点范围(公共).冗余标准数据一级目标分类ID 值等于空  and D3分析二级目标分类下指标数据点范围(公共).冗余标准数据末级目标分类ID 值等于空  and D3分析二级目标分类下指标数据点范围(公共).冗余标准数据二级目标分类ID 值不等于空 ))  71146

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setOneTargetContentNumber(reqDto.getOneTargetContentNumber01());//SimpleFieldAssign//sourceId:1912090_1_71148
receptionServiceReq_1.setOneTargetCompletionNum(reqDto.getOneTargetCompletionNum01());//SimpleFieldAssign//sourceId:1912091_1_71148
receptionServiceReq_1.setOneTargetCompletionRate(reqDto.getOneTargetCompletionRate01());//SimpleFieldAssign//sourceId:1912092_1_71148
receptionServiceReq_1.setLastTargetContentNumber(reqDto.getLastTargetContentNumber01());//SimpleFieldAssign//sourceId:1912087_1_71148
receptionServiceReq_1.setLastTargetCompletionNum(reqDto.getLastTargetCompletionNum01());//SimpleFieldAssign//sourceId:1912088_1_71148
receptionServiceReq_1.setLastTargetCompletionRate(reqDto.getLastTargetCompletionRate01());//SimpleFieldAssign//sourceId:1912089_1_71148
    }

    /*M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getOneTargetContentNumber(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标内容数不能为空",false);
Assert.isNull(receptionServiceReq_1.getOneTargetCompletionNum(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标完成数不能为空",false);
Assert.isNull(receptionServiceReq_1.getOneTargetCompletionRate(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-一级指标目标完成率不能为空",false);
Assert.isNull(receptionServiceReq_1.getLastTargetContentNumber(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标内容数不能为空",false);
Assert.isNull(receptionServiceReq_1.getLastTargetCompletionNum(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标完成数不能为空",false);
Assert.isNull(receptionServiceReq_1.getLastTargetCompletionRate(),"D3分析二级目标分类下指标数据点范围(公共)-M3-接收出参字段：目标内容数、目标内容完成数、目标内容完成率-末级指标目标完成率不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
AnalysisTwoTargetCategoryContentDataComRespDto retData = new AnalysisTwoTargetCategoryContentDataComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setOneTargetContentNumber(receptionServiceRes_1.getOneTargetContentNumber());//SimpleFieldAssign//sourceId:1912114_1
retData.setOneTargetCompletionNum(receptionServiceRes_1.getOneTargetCompletionNum());//SimpleFieldAssign//sourceId:1912115_1
retData.setOneTargetCompletionRate(receptionServiceRes_1.getOneTargetCompletionRate());//SimpleFieldAssign//sourceId:1912116_1
retData.setLastTargetContentNumber(receptionServiceRes_1.getLastTargetContentNumber());//SimpleFieldAssign//sourceId:1912117_1
retData.setLastTargetCompletionNum(receptionServiceRes_1.getLastTargetCompletionNum());//SimpleFieldAssign//sourceId:1912118_1
retData.setLastTargetCompletionRate(receptionServiceRes_1.getLastTargetCompletionRate());//SimpleFieldAssign//sourceId:1912119_1
    }




return retData;
  }
/**
   * D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)[9935]
   * gen by moon at 10/28/2024, 7:19:36 PM
   */
  @Trace(operationName = "D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto reqDto){


      List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle_1 =new ArrayList<>();
//步骤0: 3-3-09-07查询目标归属周期（大于等于时间或小于等于结束时间）-双排序列表 - queryTargetBelongCycleByGeStartOrLeEndTimeSortList
     List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListReq queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListReq();
  if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1921291_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1921292_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1921293_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1921294_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1931010_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2025250_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1921295_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2025483_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024323_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1921313_1
queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1921296_1
    }

    /*3-3-09-07查询目标归属周期（大于等于时间或小于等于结束时间）-双排序列表[9936]   */

      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByGeStartOrLeEndTimeSortList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetAttributionCycle_1 = listOmsTargetAttributionCycle;

QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto retData = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto();
  retData.setTargetBelongCycleList(listOmsTargetAttributionCycle_1.stream().map(item -> BeanUtil.toBean(item, TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1921304_1




return retData;
  }
/**
   * D3执行分段更新目标标准数据(公共)[9939]
   * gen by moon at 10/27/2024, 12:35:32 AM
   */
  @Trace(operationName = "D3执行分段更新目标标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSegUpdateTargetStandardDataComRespDto implementSegUpdateTargetStandardDataCom(ImplementSegUpdateTargetStandardDataComReqDto reqDto){


      //virtualUsage M3约定业务数据对象  71328
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("oms_target_attribution_cycle");//CUSTOM_CONVENTION//sourceId:1922126_1_71328
receptionServiceReq.setRedisDataObjectCatalogue("分段查询临时记录");//sourceId:1922125_1_71328

    /*M3约定业务数据对象[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3执行分段更新目标标准数据(公共)-M3约定业务数据对象-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getRedisDataObjectCatalogue(),"D3执行分段更新目标标准数据(公共)-M3约定业务数据对象-Redis数据对象目录不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



//virtualUsage M3执行死循环(特殊方法）  71329
      //ModelCode: endlessLoop
//        ImplementEndlessLoopRespDto endlessLoopRes = null;
//    ImplementEndlessLoopReqDto endlessLoopReq=new ImplementEndlessLoopReqDto();
//
//
//    /*M3执行死循环(特殊方法）[9401]  用于循环执行整个事务内的虚拟用况 */
//
//      endlessLoopRes = nbEvaCalc.implementEndlessLoop(endlessLoopReq);

      Long count = 0l;
//virtualUsage M3执行死循环(特殊方法）  69095
      //ModelCode: endlessLoop
      // TODO: 2024/5/31
      while(true){
          count++;
//virtualUsage D2查上一批次数据集最后一条记录Redis（业务原子）  71330
      QueryRedisBusinessDataSetDetailComRespDto queryRedisBusinessDataSetDetailComRespDto = null;
    QueryRedisBusinessDataSetDetailComReqDto queryRedisBusinessDataSetDetailComReqDto=new QueryRedisBusinessDataSetDetailComReqDto();
  queryRedisBusinessDataSetDetailComReqDto.setCustomField1("orderNumber");//CUSTOM_CONVENTION//sourceId:1922133_1_71330
if(receptionServiceRes!=null){
      queryRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1922130_1_71330
queryRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1922132_1_71330
    }
if(reqDto!=null){
      queryRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1922131_1_71330
    }

    /*D2查上一批次数据集最后一条记录Redis（业务原子）[8411]   */
    Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D3执行分段更新目标标准数据(公共)-D2查上一批次数据集最后一条记录Redis（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D3执行分段更新目标标准数据(公共)-D2查上一批次数据集最后一条记录Redis（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(),"D3执行分段更新目标标准数据(公共)-D2查上一批次数据集最后一条记录Redis（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D3执行分段更新目标标准数据(公共)-D2查上一批次数据集最后一条记录Redis（业务原子）-自定义字段1不能为空",false);
      queryRedisBusinessDataSetDetailComRespDto = fwCompBusinessAtomClient.queryRedisBusinessDataSetDetailCom(queryRedisBusinessDataSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3分段查询目标归属周期(公共)  71331
      ImplementSubsectionQueryTrgetAttributionCycleComRespDto implementSubsectionQueryTrgetAttributionCycleComRespDto = null;
    if(queryRedisBusinessDataSetDetailComRespDto !=null){
          ImplementSubsectionQueryTrgetAttributionCycleComReqDto implementSubsectionQueryTrgetAttributionCycleComReqDto=new ImplementSubsectionQueryTrgetAttributionCycleComReqDto();
  implementSubsectionQueryTrgetAttributionCycleComReqDto.setOrderFieldName("orderNumber");//CUSTOM_CONVENTION//sourceId:1921447_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setOrderRule("FROM_LARGE_TO_SMALL");//sourceId:1921448_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setBusinessDataSetPrimaryKeyName("orderNumber");//CUSTOM_CONVENTION//sourceId:1921449_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setBelongToContentTypeCode("OMS_TARGET");//CUSTOM_CONVENTION//sourceId:1922292_1_71331
if(receptionServiceRes!=null){
      implementSubsectionQueryTrgetAttributionCycleComReqDto.setBusinessDataSetTableName(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1921445_1_71331
    }
if(reqDto!=null){
      implementSubsectionQueryTrgetAttributionCycleComReqDto.setDatasNum(reqDto.getDatasNum());//SimpleFieldAssign//sourceId:1921446_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1921451_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1921452_1_71331
implementSubsectionQueryTrgetAttributionCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1921454_1_71331
    }
if(queryRedisBusinessDataSetDetailComRespDto!=null){
      implementSubsectionQueryTrgetAttributionCycleComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1921450_1_71331
    }

    /*D3分段查询目标归属周期(公共)[9664]   */
    Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getBusinessDataSetTableName(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-数据对象表名不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getDatasNum(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-数据条数不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getOrderFieldName(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-排序字段名不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getOrderRule(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-排序规则不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getBusinessDataSetPrimaryKeyName(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-数据对象主键名不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getEvaObjEntityId(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getEvaObjTypeCode(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getBelongToContentTypeCode(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementSubsectionQueryTrgetAttributionCycleComReqDto.getEvaluationTemplateId(),"D3执行分段更新目标标准数据(公共)-D3分段查询目标归属周期(公共)-评价模板ID不能为空",false);
      implementSubsectionQueryTrgetAttributionCycleComRespDto = targetCalcService.implementSubsectionQueryTrgetAttributionCycleCom(implementSubsectionQueryTrgetAttributionCycleComReqDto)/*vcase invoke isSameApp*/;



           }
if((implementSubsectionQueryTrgetAttributionCycleComRespDto!= null&&  implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList() !=null && implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList().size()>0)) {
        //if(D3分段查询目标归属周期(公共).目标归属周期列表数据集条数 大于 0)  71332

RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordComRespDto = null;
    if(implementSubsectionQueryTrgetAttributionCycleComRespDto !=null&&queryRedisBusinessDataSetDetailComRespDto !=null){
          RefreshSegQueryRedisRecordComReqDto refreshSegQueryRedisRecordComReqDto=new RefreshSegQueryRedisRecordComReqDto();
  refreshSegQueryRedisRecordComReqDto.setBusinessDataSetPrimaryKeyName("orderNumber");//CUSTOM_CONVENTION//sourceId:1921767_1_71333
if(implementSubsectionQueryTrgetAttributionCycleComRespDto!= null&&  implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList())){
      refreshSegQueryRedisRecordComReqDto.setBusinessDataSetList(implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList().stream().map(item->String.valueOf(item.getOrderNumber()))
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1921762_1_71333
    }
if(receptionServiceRes!=null){
      refreshSegQueryRedisRecordComReqDto.setBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1921763_1_71333
refreshSegQueryRedisRecordComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1921764_1_71333
    }
if(reqDto!=null){
      refreshSegQueryRedisRecordComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1921765_1_71333
    }
if(queryRedisBusinessDataSetDetailComRespDto!=null){
      refreshSegQueryRedisRecordComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1921766_1_71333
    }

    /*D2更新分段查询Redis记录(公共)[9679]   */
    Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataObject(),"D3执行分段更新目标标准数据(公共)-D2更新分段查询Redis记录(公共)-业务数据对象不能为空",false);
Assert.isNull(refreshSegQueryRedisRecordComReqDto.getRedisDataObjectCatalogue(),"D3执行分段更新目标标准数据(公共)-D2更新分段查询Redis记录(公共)-Redis数据对象目录不能为空",false);
Assert.isNull(refreshSegQueryRedisRecordComReqDto.getDataObjectBatchCode(),"D3执行分段更新目标标准数据(公共)-D2更新分段查询Redis记录(公共)-数据对象批次标识不能为空",false);
Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataSetPrimaryKeyName(),"D3执行分段更新目标标准数据(公共)-D2更新分段查询Redis记录(公共)-数据对象主键名不能为空",false);
      refreshSegQueryRedisRecordComRespDto = fwCompEvaCalcClient.refreshSegQueryRedisRecordCom(refreshSegQueryRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: circulationCollections
        for (TargetBelongCycleDto circulationCollectionsRes: implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList()){

ImplementParentSubMidCycleTypeAnalysisComRespDto implementParentSubMidCycleTypeAnalysisComRespDto = null;
    ImplementParentSubMidCycleTypeAnalysisComReqDto implementParentSubMidCycleTypeAnalysisComReqDto=new ImplementParentSubMidCycleTypeAnalysisComReqDto();
  if(circulationCollectionsRes!=null){
      implementParentSubMidCycleTypeAnalysisComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1922184_1_71341
implementParentSubMidCycleTypeAnalysisComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1922183_1_71341
    }

    /*D4-执行父子中周期类型分析(公共)[6228]   */
    Assert.isNull(implementParentSubMidCycleTypeAnalysisComReqDto.getParentSubMidCycleType(),"D3执行分段更新目标标准数据(公共)-D4-执行父子中周期类型分析(公共)-父子中周期类型不能为空",false);
Assert.isNull(implementParentSubMidCycleTypeAnalysisComReqDto.getCycleId(),"D3执行分段更新目标标准数据(公共)-D4-执行父子中周期类型分析(公共)-周期ID不能为空",false);
      implementParentSubMidCycleTypeAnalysisComRespDto = fwCalcStandardDataClient.implementParentSubMidCycleTypeAnalysisCom(implementParentSubMidCycleTypeAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
    if(implementParentSubMidCycleTypeAnalysisComRespDto !=null){
          QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1922191_1_71340
if(implementParentSubMidCycleTypeAnalysisComRespDto!=null){
      queryStandardDataOfObjectDetailComReqDto.setParentSubMidCycleType(implementParentSubMidCycleTypeAnalysisComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1922187_1_71340
queryStandardDataOfObjectDetailComReqDto.setPeriodId(implementParentSubMidCycleTypeAnalysisComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1922175_1_71340
    }
if(circulationCollectionsRes!=null){
      queryStandardDataOfObjectDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1922176_1_71340
    }
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1922177_1_71340
queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1922178_1_71340
queryStandardDataOfObjectDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1922180_1_71340
    }

    /*D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getParentSubMidCycleType(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getEntityId(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSubjectLifeCycle(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-主体生命周期不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSpaceId(),"D3执行分段更新目标标准数据(公共)-D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算)-创建于空间ID不能为空",false);
      queryStandardDataOfObjectDetailComRespDto = fwCalcStandardDataClient.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryStandardDataOfObjectDetailComRespDto!= null&& queryStandardDataOfObjectDetailComRespDto.getDataResultId() != null )) {
        //if(D4查询当前牌目标归属周期是否存在标准数据(用于判断当前周期是否继续计算).数据结果ID  值不等于空 )  71342

QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto_2 = null;
    if(implementParentSubMidCycleTypeAnalysisComRespDto !=null){
          QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto_1=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto_1.setResultType("MANUAL_INPUT");//sourceId:1922233_1_71343
queryStandardDataOfObjectDetailComReqDto_1.setStandardDataCalcCycleModel("LAST_CYCLE");//sourceId:1922230_1_71343
queryStandardDataOfObjectDetailComReqDto_1.setBelongToContentTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:1922234_1_71343
queryStandardDataOfObjectDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1922223_1_71343
if(implementParentSubMidCycleTypeAnalysisComRespDto!=null){
      queryStandardDataOfObjectDetailComReqDto_1.setPeriodId(implementParentSubMidCycleTypeAnalysisComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1922218_1_71343
    }
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1922221_1_71343
queryStandardDataOfObjectDetailComReqDto_1.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1922222_1_71343
queryStandardDataOfObjectDetailComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1922224_1_71343
    }

    /*D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getResultType(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getStandardDataCalcCycleModel(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-计算周期五模型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getThemeContentId(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataUsageSceneCode(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getBelongToContentTypeCode(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-数据归属内容表类型编码不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSubjectLifeCycle(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-主体生命周期不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSpaceId(),"D3执行分段更新目标标准数据(公共)-D4随机查询一条指标末级周期标准数据（用于获取周期阶段资料ID)-创建于空间ID不能为空",false);
      queryStandardDataOfObjectDetailComRespDto_2 = fwCalcStandardDataClient.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryStandardDataOfObjectDetailComRespDto_2!= null&& queryStandardDataOfObjectDetailComRespDto_2.getDataResultId() != null )) {
        //if(D4查询指标末级周期标准数据.数据结果ID  值不等于空 )  71344

QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    if(queryStandardDataOfObjectDetailComRespDto_2 !=null){
          QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  queryCycleStageDataDetailComReqDto.setStageContentType("STA_WOR_SUM_CON");//sourceId:1922271_1_71345
queryCycleStageDataDetailComReqDto.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1922272_1_71345
queryCycleStageDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1922276_1_71345
if(queryStandardDataOfObjectDetailComRespDto_2!=null){
      queryCycleStageDataDetailComReqDto.setCycleId(queryStandardDataOfObjectDetailComRespDto_2.getUpdateCycleId());//SimpleFieldAssign//sourceId:1922270_1_71345
queryCycleStageDataDetailComReqDto.setCycleDataObjId(queryStandardDataOfObjectDetailComRespDto_2.getEntityId());//SimpleFieldAssign//sourceId:1922273_1_71345
    }
if(reqDto!=null){
      queryCycleStageDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1922274_1_71345
    }

    /*D3查询周期阶段资料汇报任务ID[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleId(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleDataObjId(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getStageContentType(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-内容性质类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleDataTypeCode(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSubjectLifeCycle(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-主体生命周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getThemeContentId(),"D3执行分段更新目标标准数据(公共)-D3查询周期阶段资料汇报任务ID-主题内容ID不能为空",false);
      queryCycleStageDataDetailComRespDto = cycleStageDataService.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto)/*vcase invoke isSameApp*/;



           }
if((queryCycleStageDataDetailComRespDto!= null&& queryCycleStageDataDetailComRespDto.getCycleStageDataId() != null )) {
        //if(D3查询周期阶段资料汇报任务ID.周期阶段资料记录ID 值不等于空 )  71346

ImplementRefreshFullTemplateFinancialDataComRespDto implementRefreshFullTemplateFinancialDataComRespDto = null;
    if(queryCycleStageDataDetailComRespDto !=null){
          ImplementRefreshFullTemplateFinancialDataComReqDto implementRefreshFullTemplateFinancialDataComReqDto=new ImplementRefreshFullTemplateFinancialDataComReqDto();
  implementRefreshFullTemplateFinancialDataComReqDto.setDataCalcNormalAbnormal("ABNORMAL_SCENE");//sourceId:2024399_1_71347
  implementRefreshFullTemplateFinancialDataComReqDto.setExamineOptType("APPROVE");//sourceId:1922120_1_71347
if(queryCycleStageDataDetailComRespDto!=null){
      implementRefreshFullTemplateFinancialDataComReqDto.setCycleStageDataId(queryCycleStageDataDetailComRespDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1922122_1_71347
      implementRefreshFullTemplateFinancialDataComReqDto.setTaskId(queryCycleStageDataDetailComRespDto.getTaskId());//SimpleFieldAssign//sourceId:1922121_1_71347
implementRefreshFullTemplateFinancialDataComReqDto.setCycleId(queryCycleStageDataDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1922119_1_71347
implementRefreshFullTemplateFinancialDataComReqDto.setEvaObjTargetCycleId(queryCycleStageDataDetailComRespDto.getCycleDataObjId());//SimpleFieldAssign//sourceId:1922116_1_71347
    implementRefreshFullTemplateFinancialDataComReqDto.setTargetCycleContentTypeCode(queryCycleStageDataDetailComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1922123_1_71347
implementRefreshFullTemplateFinancialDataComReqDto.setTargetCycleContentId(queryCycleStageDataDetailComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1922118_1_71347
    }
if(reqDto!=null){
      implementRefreshFullTemplateFinancialDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1922117_1_71347
    }

    /*D3审核汇报材料并更新标准数据(公共)[8555]   */
    Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getDataCalcNormalAbnormal(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-数据计算正常与异常场景不能为空",false);
    Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getExamineOptType(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-审核通过或失败操作类型不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getCycleStageDataId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getTaskId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-任务ID不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getCycleId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-归属周期ID不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getEvaObjTargetCycleId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getTargetCycleContentTypeCode(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getTargetCycleContentId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementRefreshFullTemplateFinancialDataComReqDto.getEvaluationTemplateId(),"D3执行分段更新目标标准数据(公共)-D3审核汇报材料并更新标准数据(公共)-冗余评价模板ID不能为空",false);
      implementRefreshFullTemplateFinancialDataComRespDto = financeService.implementRefreshFullTemplateFinancialDataCom(implementRefreshFullTemplateFinancialDataComReqDto)/*vcase invoke isSameApp*/;



           }
      }
      }
      }
//ModelCode: circulationEnd
        }

      }
else if((implementSubsectionQueryTrgetAttributionCycleComRespDto!= null&&  implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList() !=null && implementSubsectionQueryTrgetAttributionCycleComRespDto.getTargetBelongCycleList().size()==0)) {
    //elseif(D3分段查询目标归属周期(公共).目标归属周期列表数据集条数 等于 0)  71337

    DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
    DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto = new DeleteRedisBusinessDataComReqDto();
    deleteRedisBusinessDataComReqDto.setIsDataList("FALSE");//sourceId:1921340_1_71338
    if (receptionServiceRes != null) {
        deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1921341_1_71338
        deleteRedisBusinessDataComReqDto.setBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1921337_1_71338
    }
    if (reqDto != null) {
        deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1921339_1_71338
    }

    /*D2-删除redis业务数据对象(公共)[8397]   */
    Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(), "D3执行分段更新目标标准数据(公共)-D2-删除redis业务数据对象(公共)-Redis数据对象目录不能为空", false);
    Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(), "D3执行分段更新目标标准数据(公共)-D2-删除redis业务数据对象(公共)-业务数据对象不能为空", false);
    Assert.isNull(deleteRedisBusinessDataComReqDto.getDataObjectBatchCode(), "D3执行分段更新目标标准数据(公共)-D2-删除redis业务数据对象(公共)-数据对象批次标识不能为空", false);
    Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(), "D3执行分段更新目标标准数据(公共)-D2-删除redis业务数据对象(公共)-是否是数据集对象不能为空", false);
    deleteRedisBusinessDataComRespDto = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: end
//    ImplementEndLoopRespDto endRes = null;
//    ImplementEndLoopReqDto endReq = new ImplementEndLoopReqDto();
//
//
//    /*M3执行跳出循环（特殊方法)[9403]  用于跳出死循环 */
//
//    endRes = nbEvaCalc.implementEndLoop(endReq);

    // TODO: 2024/5/31
    break;
}


    }
ImplementSegUpdateTargetStandardDataComRespDto retData = new ImplementSegUpdateTargetStandardDataComRespDto();





return retData;
  }
/**
   * D3分析父子周期最近可循环周期类型(公共)[9945]
   * gen by moon at 7/9/2024, 3:06:14 PM
   */
  @Trace(operationName = "D3分析父子周期最近可循环周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisParentSonRecyclableTypeComRespDto analysisParentSonRecyclableTypeCom(AnalysisParentSonRecyclableTypeComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))&&(reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))) {
        //if(D3分析父子周期最近可循环周期类型(公共).周期模式类型编码 等于 父子周期 and (D3分析父子周期最近可循环周期类型(公共).父子中周期类型 等于 父周期 or D3分析父子周期最近可循环周期类型(公共).父子中周期类型 等于 中期))  71390

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setNextCyclePeriod(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1924506_1_71391
    }

    /*M3接收出参：最近可循环周期类型[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))&&(reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PROCESS_CYCLE"))){
       //elseif(D3分析父子周期最近可循环周期类型(公共).周期模式类型编码 等于 父子周期 and (D3分析父子周期最近可循环周期类型(公共).父子中周期类型 等于 子周期 or D3分析父子周期最近可循环周期类型(公共).父子中周期类型 等于 过程周期))  71392

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1924506_1_71393
    }

    /*M3接收出参：最近可循环周期类型[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE"))){
       //elseif((D3分析父子周期最近可循环周期类型(公共).周期模式类型编码 等于 单周期 or D3分析父子周期最近可循环周期类型(公共).周期模式类型编码 等于 不规则周期))  71394

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1924506_1_71395
    }

    /*M3接收出参：最近可循环周期类型[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
    }
else{
       //else  71396

//异常结束 71397
      throw new BizException("C10100480","对不起，分析最近可循环周期类型错误~",false);
    }
AnalysisParentSonRecyclableTypeComRespDto retData = new AnalysisParentSonRecyclableTypeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setNextCyclePeriod(receptionServiceRes_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1924508_1
    }




return retData;
  }
/**
   * D3开启标志性成果对接(公共)[9951]
   * gen by moon at 7/13/2024, 12:49:07 AM
   */
  @Trace(operationName = "D3开启标志性成果对接(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateAchivementInterfaceComRespDto updateAchivementInterfaceCom(UpdateAchivementInterfaceComReqDto reqDto){


      //步骤0: 3-3-05查指标扩展规划设置详情 - queryTargetObjPlanExDetail
     OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
    QueryTargetObjPlanExDetailReq queryTargetObjPlanExDetailReq=new QueryTargetObjPlanExDetailReq();
  if(reqDto!=null){
      queryTargetObjPlanExDetailReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1927290_1
queryTargetObjPlanExDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1927291_1
    }

    /*3-3-05查指标扩展规划设置详情[2725]   */
    Assert.isNull(queryTargetObjPlanExDetailReq.getObjectiveId(),"D3开启标志性成果对接(公共)-3-3-05查指标扩展规划设置详情-归属指标ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getEvaluationTemplateId(),"D3开启标志性成果对接(公共)-3-3-05查指标扩展规划设置详情-冗余评价模板ID不能为空",false);
      omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExDetail(queryTargetObjPlanExDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTargetObjectivePlanExtend== null||  omsTargetObjectivePlanExtend.getObjectivePlanningExtendId() ==null,"找不到数据，系统异常",false);



//步骤1: 3-3-05修改指标扩展规划设置 - updateTargetObjPlanEx
     boolean bOOLEAN ;
    if(omsTargetObjectivePlanExtend !=null){
          OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend_2=new OmsTargetObjectivePlanExtend();
  if(omsTargetObjectivePlanExtend!=null){
      omsTargetObjectivePlanExtend_2.setObjectivePlanningExtendId(omsTargetObjectivePlanExtend.getObjectivePlanningExtendId());//SimpleFieldAssign//sourceId:1927249_1
    }
if(reqDto!=null){
      omsTargetObjectivePlanExtend_2.setIsSymbolicAchievements(reqDto.getIsSymbolicAchievements());//SimpleFieldAssign//sourceId:1927250_1
    }

    /*3-3-05修改指标扩展规划设置[2829]   */
    Assert.isNull(omsTargetObjectivePlanExtend_2.getObjectivePlanningExtendId(),"D3开启标志性成果对接(公共)-3-3-05修改指标扩展规划设置-指标扩展规划设置ID不能为空",false);
Assert.isNull(omsTargetObjectivePlanExtend_2.getIsSymbolicAchievements(),"D3开启标志性成果对接(公共)-3-3-05修改指标扩展规划设置-是否开启成果对接不能为空",false);
      bOOLEAN = mOmsTargetObjectivePlanExtendService.updateTargetObjPlanEx(omsTargetObjectivePlanExtend_2)/*vcase invoke 本地 method 方法调用;*/;



           }

UpdateAchivementInterfaceComRespDto retData = new UpdateAchivementInterfaceComRespDto();





return retData;
  }
/**
   * D3执行已成功汇报任务元素分析(公共)[9952]
   * gen by moon at 7/14/2024, 11:02:25 PM
   */
  @Trace(operationName = "D3执行已成功汇报任务元素分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSucReportTaskElementAnalyzeComRespDto implementSucReportTaskElementAnalyzeCom(ImplementSucReportTaskElementAnalyzeComReqDto reqDto){


      ImplementPrepareTargetBelongCycleDataComRespDto implementPrepareTargetBelongCycleDataComRespDto_1 =null;
QueryReportAccountSubjectEtcInfoListComRespDto queryReportAccountSubjectEtcInfoListComRespDto_1 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1929886_1
receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1929882_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1929883_1
receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1929884_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1927740_1
    }

    /*M3-接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBelongToContentId(),"D3执行已成功汇报任务元素分析(公共)-M3-接收入参字段-数据归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEntityId(),"D3执行已成功汇报任务元素分析(公共)-M3-接收入参字段-归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3执行已成功汇报任务元素分析(公共)-M3-接收入参字段-归属周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleTypeCode(),"D3执行已成功汇报任务元素分析(公共)-M3-接收入参字段-周期类型标识不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行已成功汇报任务元素分析(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1929952_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1929953_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1929951_1
    }

    /*D2-3查周期模式（评价模板配置）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行已成功汇报任务元素分析(公共)-D2-3查周期模式（评价模板配置）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行已成功汇报任务元素分析(公共)-D2-3查周期模式（评价模板配置）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行已成功汇报任务元素分析(公共)-D2-3查周期模式（评价模板配置）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D3准备目标归属周期数据(同体取小) - implementPrepareTargetBelongCycleDataCom
     ImplementPrepareTargetBelongCycleDataComRespDto implementPrepareTargetBelongCycleDataComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          ImplementPrepareTargetBelongCycleDataComReqDto implementPrepareTargetBelongCycleDataComReqDto=new ImplementPrepareTargetBelongCycleDataComReqDto();
  implementPrepareTargetBelongCycleDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1927630_1
implementPrepareTargetBelongCycleDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1927631_1
implementPrepareTargetBelongCycleDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1927636_1
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      implementPrepareTargetBelongCycleDataComReqDto.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1927637_1
    }
if(reqDto!=null){
      implementPrepareTargetBelongCycleDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1927634_1
implementPrepareTargetBelongCycleDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1927732_1
implementPrepareTargetBelongCycleDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1927632_1
implementPrepareTargetBelongCycleDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1927633_1
implementPrepareTargetBelongCycleDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1927635_1
    }

    /*D3准备目标归属周期数据(同体取小)[9424]   */
    Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getPeriodicModeTypeCode(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-周期模式类型编码不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaObjEntityId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaObjTypeCode(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getBelongToContentId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEntityId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-归属内容表主键ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getCycleId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-归属周期ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getCycleTypeCode(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-周期类型标识不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getEvaluationTemplateId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-冗余评价模板ID不能为空",false);
Assert.isNull(implementPrepareTargetBelongCycleDataComReqDto.getSpaceId(),"D3执行已成功汇报任务元素分析(公共)-D3准备目标归属周期数据(同体取小)-创建于空间ID不能为空",false);
      implementPrepareTargetBelongCycleDataComRespDto = targetCalcService.implementPrepareTargetBelongCycleDataCom(implementPrepareTargetBelongCycleDataComReqDto)/*vcase invoke isSameApp*/;


      implementPrepareTargetBelongCycleDataComRespDto_1 = implementPrepareTargetBelongCycleDataComRespDto;
           }

//步骤3: D3查询汇报财务科目等信息(公共) - queryReportAccountSubjectEtcInfoListCom
     QueryReportAccountSubjectEtcInfoListComRespDto queryReportAccountSubjectEtcInfoListComRespDto = null;
    if(implementPrepareTargetBelongCycleDataComRespDto !=null){
          QueryReportAccountSubjectEtcInfoListComReqDto queryReportAccountSubjectEtcInfoListComReqDto=new QueryReportAccountSubjectEtcInfoListComReqDto();
  if(implementPrepareTargetBelongCycleDataComRespDto!=null){
      queryReportAccountSubjectEtcInfoListComReqDto.setBudgetAmountElement(implementPrepareTargetBelongCycleDataComRespDto.getBudgetAmountElement());//SimpleFieldAssign//sourceId:1927736_1
    }
if(reqDto!=null){
      queryReportAccountSubjectEtcInfoListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1927737_1
    }

    /*D3查询汇报财务科目等信息(公共)[9426]   */
    Assert.isNull(queryReportAccountSubjectEtcInfoListComReqDto.getEvaluationTemplateId(),"D3执行已成功汇报任务元素分析(公共)-D3查询汇报财务科目等信息(公共)-冗余评价模板ID不能为空",false);
      queryReportAccountSubjectEtcInfoListComRespDto = targetCalcService.queryReportAccountSubjectEtcInfoListCom(queryReportAccountSubjectEtcInfoListComReqDto)/*vcase invoke isSameApp*/;


      queryReportAccountSubjectEtcInfoListComRespDto_1 = queryReportAccountSubjectEtcInfoListComRespDto;
           }

ImplementSucReportTaskElementAnalyzeComRespDto retData = new ImplementSucReportTaskElementAnalyzeComRespDto();
  if(implementPrepareTargetBelongCycleDataComRespDto_1!=null){
      retData.setTargetCycleContentTypeCode(implementPrepareTargetBelongCycleDataComRespDto_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1929892_1
retData.setBelongToContentId(implementPrepareTargetBelongCycleDataComRespDto_1.getBelongToContentId());//SimpleFieldAssign//sourceId:1929893_1
retData.setIsLastObjective(implementPrepareTargetBelongCycleDataComRespDto_1.getIsLastObjective());//SimpleFieldAssign//sourceId:1929894_1
retData.setTargetValueType(implementPrepareTargetBelongCycleDataComRespDto_1.getTargetValueType());//SimpleFieldAssign//sourceId:1929895_1
retData.setProgressValueElement(implementPrepareTargetBelongCycleDataComRespDto_1.getProgressValueElement());//SimpleFieldAssign//sourceId:1929896_1
retData.setActualValueElement(implementPrepareTargetBelongCycleDataComRespDto_1.getActualValueElement());//SimpleFieldAssign//sourceId:1929897_1
retData.setBudgetAmountElement(implementPrepareTargetBelongCycleDataComRespDto_1.getBudgetAmountElement());//SimpleFieldAssign//sourceId:1929898_1
retData.setEvaActualCalcCode(implementPrepareTargetBelongCycleDataComRespDto_1.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1933325_1
    }
if(queryReportAccountSubjectEtcInfoListComRespDto_1!=null){
      retData.setAccountSubjectList(queryReportAccountSubjectEtcInfoListComRespDto_1.getAccountSubjectList().stream().map(item -> BeanUtil.toBean(item, AccountSubjectDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1929899_1
retData.setAccountUnit(queryReportAccountSubjectEtcInfoListComRespDto_1.getAccountUnit());//SimpleFieldAssign//sourceId:1929900_1
    }




return retData;
  }
/**
   * D3执行汇报数据质检操作元素(公共)[9954]
   * gen by moon at 7/14/2024, 12:28:34 AM
   */
  @Trace(operationName = "D3执行汇报数据质检操作元素(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementReportDataQualityOperationElementComRespDto implementReportDataQualityOperationElementCom(ImplementReportDataQualityOperationElementComReqDto reqDto){


      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 =null;
      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
ImplementElevenReceivingFieldRespDto receptionServiceRes_5 =null;
ImplementElevenReceivingFieldRespDto receptionServiceRes_8 =null;
ImplementElevenReceivingFieldRespDto receptionServiceRes_16 =null;
OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend_1 =null;
//virtualUsage M3-约定数值：0、2  71484
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1929808_1_71484
receptionServiceReq.setComNumField2(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1929809_1_71484

    /*M3-约定数值：0、2[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComNumField(),"D3执行汇报数据质检操作元素(公共)-M3-约定数值：0、2-通用数值字段（整数型）不能为空",false);
Assert.isNull(receptionServiceReq.getComNumField2(),"D3执行汇报数据质检操作元素(公共)-M3-约定数值：0、2-通用数值字段2（整数型）不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



//virtualUsage D2查是否开启标志性成果  71515
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_SYMBOLIC_ACHIEVEMENTS");//CUSTOM_CONVENTION//sourceId:1928105_1_71515
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1928106_1_71515
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1928104_1_71515
    }

    /*D2查是否开启标志性成果[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行汇报数据质检操作元素(公共)-D2查是否开启标志性成果-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行汇报数据质检操作元素(公共)-D2查是否开启标志性成果-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行汇报数据质检操作元素(公共)-D2查是否开启标志性成果-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
//virtualUsage D2查进度型指标是否开启成果对接  71516
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("PROCESS_IS_OPEN_ACHIVE_DOCKING");//CUSTOM_CONVENTION//sourceId:1929471_1_71516
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1929472_1_71516
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1929470_1_71516
    }

    /*D2查进度型指标是否开启成果对接[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3执行汇报数据质检操作元素(公共)-D2查进度型指标是否开启成果对接-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3执行汇报数据质检操作元素(公共)-D2查进度型指标是否开启成果对接-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3执行汇报数据质检操作元素(公共)-D2查进度型指标是否开启成果对接-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
if((reqDto!= null&& reqDto.getProgressValueElement() != null )) {
        //if(D3执行汇报数据质检操作元素(公共).汇报进度值元素 值不等于空 )  71470

if((reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("TRUE")&&reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("PROGRESS")&&reqDto!= null&& reqDto.getProgressValueElement() == 2L)&&(queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE")||queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("ONLY_UPLOAD"))&&(queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("TRUE"))) {
        //if((D3执行汇报数据质检操作元素(公共).是否末级指标 等于 是 and D3执行汇报数据质检操作元素(公共).冗余指标业务类型 等于 进度型 and D3执行汇报数据质检操作元素(公共).汇报进度值元素 等于 2) and (D2查是否开启标志性成果.答案值 等于 是 or D2查是否开启标志性成果.答案值 等于 只上传标志性成果) and D2查进度型指标是否开启成果对接.答案值 等于 是)  71520

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setProgressValueElement(reqDto.getProgressValueElement());//SimpleFieldAssign//sourceId:1929098_1_71522
    }

    /*M3-接收字段：汇报进度值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getProgressValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报进度值元素-汇报进度值元素不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setAchievementDockingElement(receptionServiceRes.getComNumField2());//SimpleFieldAssign//sourceId:1929445_1_71521
    }

    /*M3-接收字段：汇报成果元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getAchievementDockingElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报成果元素-汇报成果元素不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else{
       //else  71523

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_3.setProgressValueElement(reqDto.getProgressValueElement());//SimpleFieldAssign//sourceId:1929098_1_71525
    }

    /*M3-接收字段：汇报进度值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getProgressValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报进度值元素-汇报进度值元素不能为空",false);
      receptionServiceRes_6 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
      }
if((reqDto!= null&& reqDto.getActualValueElement() != null )) {
        //if(D3执行汇报数据质检操作元素(公共).汇报实际值元素 值不等于空 )  71472

if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE")||queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("ONLY_UPLOAD"))) {
        //if((D2查是否开启标志性成果.答案值 等于 是 or D2查是否开启标志性成果.答案值 等于 只上传标志性成果))  71476

if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("PROGRESS")&&queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("TRUE")&&reqDto!= null&& reqDto.getActualValueElement() == 2L)) {
        //if((D3执行汇报数据质检操作元素(公共).冗余指标业务类型 等于 进度型 and D2查进度型指标是否开启成果对接.答案值 等于 是 and D3执行汇报数据质检操作元素(公共).汇报实际值元素 等于 2))  71487

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_7 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_4=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_4.setActualValueElement(reqDto.getActualValueElement());//SimpleFieldAssign//sourceId:1929107_1_71489
    }

    /*M3-接收字段：汇报实际值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getActualValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报实际值元素-汇报实际值元素不能为空",false);
      receptionServiceRes_7 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_8 = receptionServiceRes_7;
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_9 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_5=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setAchievementDockingElement(receptionServiceRes.getComNumField2());//SimpleFieldAssign//sourceId:1929445_1_71488
    }

    /*M3-接收字段：汇报成果元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getAchievementDockingElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报成果元素-汇报成果元素不能为空",false);
      receptionServiceRes_9 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_5);


      receptionServiceRes_5 = receptionServiceRes_9;
      }
else if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("NUMBER_GROWTH")&&reqDto!= null&& reqDto.getActualValueElement() == 2L)){
       //elseif((D3执行汇报数据质检操作元素(公共).冗余指标业务类型 等于 数量增长型 and D3执行汇报数据质检操作元素(公共).汇报实际值元素 等于 2))  71490

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_10 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_6=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_6.setActualValueElement(receptionServiceRes.getComNumField2());//SimpleFieldAssign//sourceId:1929107_1_71492
    }

    /*M3-接收字段：汇报实际值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getActualValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报实际值元素-汇报实际值元素不能为空",false);
      receptionServiceRes_10 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_6);


      receptionServiceRes_8 = receptionServiceRes_10;
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_11 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_7=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setAchievementDockingElement(receptionServiceRes.getComNumField2());//SimpleFieldAssign//sourceId:1929445_1_71491
    }

    /*M3-接收字段：汇报成果元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getAchievementDockingElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报成果元素-汇报成果元素不能为空",false);
      receptionServiceRes_11 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_7);


      receptionServiceRes_5 = receptionServiceRes_11;
    }
else{
       //else  71493

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_12 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_8=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_8.setActualValueElement(reqDto.getActualValueElement());//SimpleFieldAssign//sourceId:1929107_1_71494
    }

    /*M3-接收字段：汇报实际值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getActualValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报实际值元素-汇报实际值元素不能为空",false);
      receptionServiceRes_12 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_8);


      receptionServiceRes_8 = receptionServiceRes_12;
    }
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE"))){
       //elseif(D2查是否开启标志性成果.答案值 等于 否)  71477

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_13 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_9=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_9.setActualValueElement(reqDto.getActualValueElement());//SimpleFieldAssign//sourceId:1929107_1_71485
    }

    /*M3-接收字段：汇报实际值元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_9.getActualValueElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报实际值元素-汇报实际值元素不能为空",false);
      receptionServiceRes_13 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_9);


      receptionServiceRes_8 = receptionServiceRes_13;
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_14 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_10=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_10.setAchievementDockingElement(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1929445_1_71483
    }

    /*M3-接收字段：汇报成果元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_10.getAchievementDockingElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报成果元素-汇报成果元素不能为空",false);
      receptionServiceRes_14 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_10);


      receptionServiceRes_5 = receptionServiceRes_14;
    }
      }
if((reqDto!= null&& reqDto.getBudgetAmountElement() != null )) {
        //if(D3执行汇报数据质检操作元素(公共).汇报预算元素 值不等于空 )  71474

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_15 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_11=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_11.setBudgetAmountElement(reqDto.getBudgetAmountElement());//SimpleFieldAssign//sourceId:1929443_1_71480
    }

    /*M3-接收字段：汇报预算元素[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_11.getBudgetAmountElement(),"D3执行汇报数据质检操作元素(公共)-M3-接收字段：汇报预算元素-汇报预算元素不能为空",false);
      receptionServiceRes_15 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_11);


      receptionServiceRes_16 = receptionServiceRes_15;
      }
if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getEndValue() == null ||queryConfItemMatchAnswerDetailComRespDto_2!= null&& queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() == null )||(queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE")&&queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("TRUE"))) {
        //if((D2查是否开启标志性成果.答案值 值等于空  or D2查进度型指标是否开启成果对接.答案值 值等于空 ) or (D2查是否开启标志性成果.答案值 等于 否 and D2查进度型指标是否开启成果对接.答案值 等于 是))  71518

//异常结束 71519
      throw new BizException("220200353","对不起，数据配置异常~",false);
      }
if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D3执行汇报数据质检操作元素(公共).关联目标内容类型编码 等于 指标)  71528

OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
    QueryObjtiveExtSetDetailReq queryObjtiveExtSetDetailReq=new QueryObjtiveExtSetDetailReq();
  if(reqDto!=null){
      queryObjtiveExtSetDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1929861_1_71529
queryObjtiveExtSetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1929864_1_71529
    }

    /*3-3-05查询指标扩展设置详情[9246]   */
    Assert.isNull(queryObjtiveExtSetDetailReq.getObjectiveId(),"D3执行汇报数据质检操作元素(公共)-3-3-05查询指标扩展设置详情-归属指标ID不能为空",false);
Assert.isNull(queryObjtiveExtSetDetailReq.getEvaluationTemplateId(),"D3执行汇报数据质检操作元素(公共)-3-3-05查询指标扩展设置详情-冗余评价模板ID不能为空",false);
      omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryObjtiveExtSetDetail(queryObjtiveExtSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetObjectivePlanExtend_1 = omsTargetObjectivePlanExtend;
      }
ImplementReportDataQualityOperationElementComRespDto retData = new ImplementReportDataQualityOperationElementComRespDto();
  if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setIsOpenSymbolicAchievements(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1931003_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      retData.setProcessIsOpenAchiveDocking(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:1931004_1
    }
  if(receptionServiceRes_3!=null){
      retData.setProgressValueElement(receptionServiceRes_3.getProgressValueElement());//SimpleFieldAssign//sourceId:1929814_1
    }
if(receptionServiceRes_8!=null){
      retData.setActualValueElement(receptionServiceRes_8.getActualValueElement());//SimpleFieldAssign//sourceId:1929815_1
    }
if(receptionServiceRes_16!=null){
      retData.setBudgetAmountElement(receptionServiceRes_16.getBudgetAmountElement());//SimpleFieldAssign//sourceId:1929816_1
    }
if(receptionServiceRes_5!=null){
      retData.setAchievementDockingElement(receptionServiceRes_5.getAchievementDockingElement());//SimpleFieldAssign//sourceId:1929817_1
    }
if(omsTargetObjectivePlanExtend_1!=null){
      retData.setIsSymbolicAchievements(omsTargetObjectivePlanExtend_1.getIsSymbolicAchievements());//SimpleFieldAssign//sourceId:1929876_1
    }




return retData;
  }
/**
   * D3执行修正总结资料及图片(公共)[9956]
   * gen by moon at 7/16/2024, 12:44:18 AM
   */
  @Trace(operationName = "D3执行修正总结资料及图片(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAdjustedCompilationMaterialsOrPicComRespDto implementAdjustedCompilationMaterialsOrPicCom(ImplementAdjustedCompilationMaterialsOrPicComReqDto reqDto){


      //virtualUsage 3-3-11查周期阶段资料详情  71567
      OmsTspeCycleStageData omsTspeCycleStageData = null;
    QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  if(reqDto!=null){
      queryCycleStageDataDetailReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1931531_1_71567
queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1931532_1_71567
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getCycleStageDataId(),"D3执行修正总结资料及图片(公共)-3-3-11查周期阶段资料详情-周期阶段资料记录ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3执行修正总结资料及图片(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTspeCycleStageData== null||  omsTspeCycleStageData.getCycleStageDataId() ==null,"找不到数据，系统异常",false);


//virtualUsage 3-3-09查目标周期详情（获取内容类型、内容ID）  71569
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    if(omsTspeCycleStageData !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  if(omsTspeCycleStageData!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(omsTspeCycleStageData.getCycleDataObjId());//SimpleFieldAssign//sourceId:1931477_1_71569
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1931478_1_71569
    }

    /*3-3-09查目标周期详情（获取内容类型、内容ID）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3执行修正总结资料及图片(公共)-3-3-09查目标周期详情（获取内容类型、内容ID）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行修正总结资料及图片(公共)-3-3-09查目标周期详情（获取内容类型、内容ID）-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() ==null,"找不到数据，系统异常",false);


           }
if((reqDto!= null&&  reqDto.getDocumentList() !=null && reqDto.getDocumentList().size()>0||reqDto!= null&&  reqDto.getDocumentList() !=null && reqDto.getDocumentList().size()==0)) {
        //if((D3执行修正总结资料及图片(公共).文档列表数据集条数 大于 0 or D3执行修正总结资料及图片(公共).文档列表数据集条数 等于 0))  71570

ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1931534_1_71571
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3执行修正总结资料及图片(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementHandleCycleStageDataDocComRespDto implementHandleCycleStageDataDocComRespDto = null;
    if(omsTspeCycleStageData !=null&&omsEvaluationObjectTargetCycle !=null&&implementContentTypeChangeTableTypeComRespDto !=null){
          ImplementHandleCycleStageDataDocComReqDto implementHandleCycleStageDataDocComReqDto=new ImplementHandleCycleStageDataDocComReqDto();
  implementHandleCycleStageDataDocComReqDto.setOwnTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1931026_1_71572
implementHandleCycleStageDataDocComReqDto.setDocUseSceneCode("PLANNING");//sourceId:1931030_1_71572
implementHandleCycleStageDataDocComReqDto.setHandleDataDocumentScene("HANDLE_THUMBNAIL");//sourceId:1933398_1_71572
implementHandleCycleStageDataDocComReqDto.setPicDocUseType("REPORT_THUMBNAIL");
implementHandleCycleStageDataDocComReqDto.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:1931024_1_71572
implementHandleCycleStageDataDocComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1931031_1_71572
if(reqDto!=null){
      implementHandleCycleStageDataDocComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1931019_1_71572
implementHandleCycleStageDataDocComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1931032_1_71572
    }
if(omsTspeCycleStageData!=null){
      implementHandleCycleStageDataDocComReqDto.setIsActualReceptionCycle(omsTspeCycleStageData.getIsActualReceptionCycle());//SimpleFieldAssign//sourceId:1931533_1_71572
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementHandleCycleStageDataDocComReqDto.setOwnWorkCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1931025_1_71572
implementHandleCycleStageDataDocComReqDto.setOwnParentContentCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1931028_1_71572
implementHandleCycleStageDataDocComReqDto.setOwnParentContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1931029_1_71572
    }
if(implementContentTypeChangeTableTypeComRespDto!=null){
      implementHandleCycleStageDataDocComReqDto.setOwnParentContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1931027_1_71572
    }
if(reqDto!= null&&  reqDto.getDocumentList() !=null&& !CollectionUtil.isEmpty(reqDto.getDocumentList())){
      implementHandleCycleStageDataDocComReqDto.setDocumentList(reqDto.getDocumentList().stream().map(item -> BeanUtil.toBean(item, DocumentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1931018_1_71572
    }

    /*D3-执行周期阶段资料相关文档处理(公共)[5490]   */
    Assert.isNull(implementHandleCycleStageDataDocComReqDto.getCycleStageDataId(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getOwnTableTypeCode(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getDocUseSceneCode(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-文档应用业务场景不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getHandleDataDocumentScene(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-处理资料文档关系场景不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getPicDocUseType(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-文档用途类型（九宫格图片）不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getIsActualReceptionCycle(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-是否实际验收周期不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getUserId(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属个人账号ID不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getOwnWorkCycleId(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属工作周期ID不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getOwnParentContentTypeCode(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属父内容表类型编码不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getOwnParentContentCode(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属父内容标识不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getOwnParentContentId(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-归属父内容表主键ID不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getThemeContentTypeCode(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-主题内容表类型编码不能为空",false);
Assert.isNull(implementHandleCycleStageDataDocComReqDto.getThemeContentId(),"D3执行修正总结资料及图片(公共)-D3-执行周期阶段资料相关文档处理(公共)-主题内容ID不能为空",false);
      implementHandleCycleStageDataDocComRespDto = cycleStageDataService.implementHandleCycleStageDataDocCom(implementHandleCycleStageDataDocComReqDto)/*vcase invoke isSameApp*/;



           }
      }
if((reqDto!= null&& reqDto.getStaWorSumCon() != null )) {
        //if(D3执行修正总结资料及图片(公共).阶段工作总结内容 值不等于空 )  71563

ImplementHandleStaWorSumConComRespDto implementHandleStaWorSumConComRespDto = null;
    ImplementHandleStaWorSumConComReqDto implementHandleStaWorSumConComReqDto=new ImplementHandleStaWorSumConComReqDto();
  implementHandleStaWorSumConComReqDto.setReleationContTypeCode("CYCLE_STAGE_DATA");//sourceId:1931038_1_71564
implementHandleStaWorSumConComReqDto.setHypertextType("STA_WOR_SUM_CON");//sourceId:1931037_1_71564
implementHandleStaWorSumConComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1931039_1_71564
if(reqDto!=null){
      implementHandleStaWorSumConComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1931034_1_71564
implementHandleStaWorSumConComReqDto.setStaWorSumCon(reqDto.getStaWorSumCon());//SimpleFieldAssign//sourceId:1931035_1_71564
implementHandleStaWorSumConComReqDto.setTextSummaryData(reqDto.getTextSummaryData());//SimpleFieldAssign//sourceId:1931036_1_71564
implementHandleStaWorSumConComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1931040_1_71564
    }

    /*D3-执行阶段工作总结内容资料处理(公共)[5488]   */
    Assert.isNull(implementHandleStaWorSumConComReqDto.getCycleStageDataId(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(implementHandleStaWorSumConComReqDto.getStaWorSumCon(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-阶段工作总结内容不能为空",false);
Assert.isNull(implementHandleStaWorSumConComReqDto.getReleationContTypeCode(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-超文本内容关联类型编码不能为空",false);
Assert.isNull(implementHandleStaWorSumConComReqDto.getHypertextType(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-超文本内容类型不能为空",false);
Assert.isNull(implementHandleStaWorSumConComReqDto.getThemeContentTypeCode(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-主题内容类型编码不能为空",false);
Assert.isNull(implementHandleStaWorSumConComReqDto.getThemeContentId(),"D3执行修正总结资料及图片(公共)-D3-执行阶段工作总结内容资料处理(公共)-主题内容ID不能为空",false);
      implementHandleStaWorSumConComRespDto = cycleStageDataService.implementHandleStaWorSumConCom(implementHandleStaWorSumConComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementAdjustedCompilationMaterialsOrPicComRespDto retData = new ImplementAdjustedCompilationMaterialsOrPicComRespDto();





return retData;
  }
/**
   * D3执行校验下级过程执行周期合理性(公共)[9960]
   * gen by moon at 7/14/2024, 11:28:02 PM
   */
  @Trace(operationName = "D3执行校验下级过程执行周期合理性(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCheckSubExecutionCycleRationalityComRespDto implementCheckSubExecutionCycleRationalityCom(ImplementCheckSubExecutionCycleRationalityComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3查下级目标内容列表（用于入参查下级目标内容执行周期）  71585
      QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setIsParentCycle("TRUE");//sourceId:1932824_1_71585
queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1932828_1_71585
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1932831_1_71585
queryEvaTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1932819_1_71585
queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1932820_1_71585
queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932827_1_71585
    }

    /*D3查下级目标内容列表（用于入参查下级目标内容执行周期）[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getParentEvaObjTargetCycleId(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsParentCycle(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-是否父周期不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3执行校验下级过程执行周期合理性(公共)-D3查下级目标内容列表（用于入参查下级目标内容执行周期）-是否存档不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查下级目标内容列表（用于入参查下级目标内容执行周期）.被评对象目标周期列表数据集条数 大于 0)  71586

BatchQueryExecuteCycleByContIdListByIdsComRespDto batchQueryExecuteCycleByContIdListByIdsComRespDto = null;
    if(queryEvaTargetCycleListComRespDto !=null){
          BatchQueryExecuteCycleByContIdListByIdsComReqDto batchQueryExecuteCycleByContIdListByIdsComReqDto=new BatchQueryExecuteCycleByContIdListByIdsComReqDto();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      batchQueryExecuteCycleByContIdListByIdsComReqDto.setExecuteCycleStageList(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getTargetCycleContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1932908_1_71588
    }
if(reqDto!=null){
      batchQueryExecuteCycleByContIdListByIdsComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1932909_1_71588
batchQueryExecuteCycleByContIdListByIdsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932910_1_71588
    }

    /*D3入参周期ID批量查询下级执行周期阶段列表(公共)[9963]   */
    Assert.isNull(batchQueryExecuteCycleByContIdListByIdsComReqDto.getCycleId(),"D3执行校验下级过程执行周期合理性(公共)-D3入参周期ID批量查询下级执行周期阶段列表(公共)-周期ID不能为空",false);
Assert.isNull(batchQueryExecuteCycleByContIdListByIdsComReqDto.getEvaluationTemplateId(),"D3执行校验下级过程执行周期合理性(公共)-D3入参周期ID批量查询下级执行周期阶段列表(公共)-评价模板ID不能为空",false);
      batchQueryExecuteCycleByContIdListByIdsComRespDto = executeCycleService.batchQueryExecuteCycleByContIdListByIdsCom(batchQueryExecuteCycleByContIdListByIdsComReqDto)/*vcase invoke isSameApp*/;



           }
if((batchQueryExecuteCycleByContIdListByIdsComRespDto!= null&&  batchQueryExecuteCycleByContIdListByIdsComRespDto.getExecuteCycleStageList() !=null && batchQueryExecuteCycleByContIdListByIdsComRespDto.getExecuteCycleStageList().size()==0)) {
        //if(D3入参周期ID批量查询下级执行周期阶段列表(公共).执行周期阶段列表数据集条数 等于 0)  71591

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("下级目标成果汇报开始或结束时间设置不合理，请重新检查并设置~");//CUSTOM_CONVENTION//sourceId:1933261_1_71592

    /*M3约定出参下级目标成果汇报时间设置错误文案[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3执行校验下级过程执行周期合理性(公共)-M3约定出参下级目标成果汇报时间设置错误文案-自定义字段1不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
      }
ImplementCheckSubExecutionCycleRationalityComRespDto retData = new ImplementCheckSubExecutionCycleRationalityComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setReportSetCheckCopywriting(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1933262_1
    }




return retData;
  }
/**
   * D3执行循环校验过程执行周期合理性(公共)[9961]
   * gen by moon at 7/14/2024, 11:02:57 PM
   */
  @Trace(operationName = "D3执行循环校验过程执行周期合理性(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopCheckExecutionCycleRationalityComRespDto implementLoopCheckExecutionCycleRationalityCom(ImplementLoopCheckExecutionCycleRationalityComReqDto reqDto){


      ImplementCheckSubExecutionCycleRationalityComRespDto implementCheckSubExecutionCycleRationalityComRespDto_1 =null;
//virtualUsage D2查是否开启自定义汇报  71587
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1932884_1_71587
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_CUSTOM_REPORT");//CUSTOM_CONVENTION//sourceId:1932885_1_71587
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1932886_1_71587
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932883_1_71587
    }

    /*D2查是否开启自定义汇报[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行循环校验过程执行周期合理性(公共)-D2查是否开启自定义汇报-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3执行循环校验过程执行周期合理性(公共)-D2查是否开启自定义汇报-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行循环校验过程执行周期合理性(公共)-D2查是否开启自定义汇报-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行循环校验过程执行周期合理性(公共)-D2查是否开启自定义汇报-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE"))) {
        //if(D2查是否开启自定义汇报.答案值 等于 是)  71589

QueryExecuteCycleByEvaTempListComRespDto queryExecuteCycleByEvaTempListComRespDto = null;
    QueryExecuteCycleByEvaTempListComReqDto queryExecuteCycleByEvaTempListComReqDto=new QueryExecuteCycleByEvaTempListComReqDto();
  queryExecuteCycleByEvaTempListComReqDto.setIsLastCycle("TRUE");//sourceId:1933277_1_71593
queryExecuteCycleByEvaTempListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1933271_1_71593
queryExecuteCycleByEvaTempListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1933272_1_71593
if(reqDto!=null){
      queryExecuteCycleByEvaTempListComReqDto.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1933276_1_71593
queryExecuteCycleByEvaTempListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1933270_1_71593
    }

    /*D3查询执行周期阶段列表(公共)[9854]   */
    Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getRelateContentId(),"D3执行循环校验过程执行周期合理性(公共)-D3查询执行周期阶段列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getEvaluationTemplateId(),"D3执行循环校验过程执行周期合理性(公共)-D3查询执行周期阶段列表(公共)-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getIsLastCycle(),"D3执行循环校验过程执行周期合理性(公共)-D3查询执行周期阶段列表(公共)-是否末级周期不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSubjectLifeCycle(),"D3执行循环校验过程执行周期合理性(公共)-D3查询执行周期阶段列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSpaceId(),"D3执行循环校验过程执行周期合理性(公共)-D3查询执行周期阶段列表(公共)-创建于空间ID不能为空",false);
      queryExecuteCycleByEvaTempListComRespDto = executeCycleService.queryExecuteCycleByEvaTempListCom(queryExecuteCycleByEvaTempListComReqDto)/*vcase invoke isSameApp*/;



if((queryExecuteCycleByEvaTempListComRespDto!= null&&  queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList() !=null && queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList().size()>0)) {
        //if(D3查询执行周期阶段列表(公共).执行周期阶段列表数据集条数 大于 0)  71594

//ModelCode: circulationCollections
        for (ExecuteCycleStageDto circulationCollectionsRes: queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList()){

ImplementCheckSubExecutionCycleRationalityComRespDto implementCheckSubExecutionCycleRationalityComRespDto = null;
    ImplementCheckSubExecutionCycleRationalityComReqDto implementCheckSubExecutionCycleRationalityComReqDto=new ImplementCheckSubExecutionCycleRationalityComReqDto();
  if(reqDto!=null){
      implementCheckSubExecutionCycleRationalityComReqDto.setParentEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1933302_1_71597
implementCheckSubExecutionCycleRationalityComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1933305_1_71597
implementCheckSubExecutionCycleRationalityComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1933306_1_71597
implementCheckSubExecutionCycleRationalityComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1933303_1_71597
    }
if(circulationCollectionsRes!=null){
      implementCheckSubExecutionCycleRationalityComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1933304_1_71597
    }

    /*D3执行校验下级过程执行周期合理性(公共)[9960]   */
    Assert.isNull(implementCheckSubExecutionCycleRationalityComReqDto.getParentEvaObjTargetCycleId(),"D3执行循环校验过程执行周期合理性(公共)-D3执行校验下级过程执行周期合理性(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(implementCheckSubExecutionCycleRationalityComReqDto.getEvaObjEntityId(),"D3执行循环校验过程执行周期合理性(公共)-D3执行校验下级过程执行周期合理性(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCheckSubExecutionCycleRationalityComReqDto.getEvaObjTypeCode(),"D3执行循环校验过程执行周期合理性(公共)-D3执行校验下级过程执行周期合理性(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementCheckSubExecutionCycleRationalityComReqDto.getCycleId(),"D3执行循环校验过程执行周期合理性(公共)-D3执行校验下级过程执行周期合理性(公共)-周期ID不能为空",false);
Assert.isNull(implementCheckSubExecutionCycleRationalityComReqDto.getEvaluationTemplateId(),"D3执行循环校验过程执行周期合理性(公共)-D3执行校验下级过程执行周期合理性(公共)-冗余评价模板ID不能为空",false);
      implementCheckSubExecutionCycleRationalityComRespDto = implementCheckSubExecutionCycleRationalityCom(implementCheckSubExecutionCycleRationalityComReqDto)/*vcase invoke 同服务,同domain*/;


      implementCheckSubExecutionCycleRationalityComRespDto_1 = implementCheckSubExecutionCycleRationalityComRespDto;
if((implementCheckSubExecutionCycleRationalityComRespDto!= null&& implementCheckSubExecutionCycleRationalityComRespDto.getReportSetCheckCopywriting() != null )) {
        //if(D3执行校验下级过程执行周期合理性(公共).成果汇报设置校验文案 值不等于空 )  71598

//processBranchName:跳出循环 ,processBranchId:71599
        break;
      }
//ModelCode: circulationEnd
        }

      }
      }
ImplementLoopCheckExecutionCycleRationalityComRespDto retData = new ImplementLoopCheckExecutionCycleRationalityComRespDto();
  if(implementCheckSubExecutionCycleRationalityComRespDto_1!=null){
      retData.setReportSetCheckCopywriting(implementCheckSubExecutionCycleRationalityComRespDto_1.getReportSetCheckCopywriting());//SimpleFieldAssign//sourceId:1933312_1
    }




return retData;
  }
/**
   * D3执行删业务应用超文本(公共)[9982]
   * gen by moon at 7/20/2024, 3:09:01 PM
   */
  @Trace(operationName = "D3执行删业务应用超文本(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDelBizAppHypertextContentComRespDto implementDelBizAppHypertextContentCom(ImplementDelBizAppHypertextContentComReqDto reqDto){


      //步骤0: 3-5-2查询业务应用超文本内容列表 - queryBusAppHypertextContentList
     List<OmsBizAppHypertextContent> listOmsBizAppHypertextContent =new ArrayList<>();
    QueryBusAppHypertextContentListReq queryBusAppHypertextContentListReq=new QueryBusAppHypertextContentListReq();
  if(reqDto!=null){
      queryBusAppHypertextContentListReq.setReleationContId(reqDto.getReleationContId());//SimpleFieldAssign//sourceId:1940056_1
queryBusAppHypertextContentListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940058_1
    }

    /*3-5-2查询业务应用超文本内容列表[4616]   */
    Assert.isNull(queryBusAppHypertextContentListReq.getReleationContId(),"D3执行删业务应用超文本(公共)-3-5-2查询业务应用超文本内容列表-超文本内容关联主键ID不能为空",false);
Assert.isNull(queryBusAppHypertextContentListReq.getThemeContentId(),"D3执行删业务应用超文本(公共)-3-5-2查询业务应用超文本内容列表-主题内容ID不能为空",false);
      listOmsBizAppHypertextContent = mOmsBizAppHypertextContentService.queryBusAppHypertextContentList(queryBusAppHypertextContentListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-5-2批量删超文本内容 - batchDeleteHypertextContent
     boolean bOOLEAN ;
    if(listOmsBizAppHypertextContent !=null&& !CollectionUtil.isEmpty(listOmsBizAppHypertextContent)&& listOmsBizAppHypertextContent.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsBizAppHypertextContent!= null&& !CollectionUtil.isEmpty(listOmsBizAppHypertextContent)&&  listOmsBizAppHypertextContent !=null&& !CollectionUtil.isEmpty(listOmsBizAppHypertextContent)){
      listString = listOmsBizAppHypertextContent.stream().map(item->item.getHypertextContentId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1940059_1
    }

    /*3-5-2批量删超文本内容[4227]   */

      bOOLEAN = mOmsBizAppHypertextContentService.batchDeleteHypertextContent(listString)/*vcase invoke 本地 method 方法调用;*/;



           }

ImplementDelBizAppHypertextContentComRespDto retData = new ImplementDelBizAppHypertextContentComRespDto();





return retData;
  }
/**
   * D3执行删除汇报任务(公共)[9984]
   * gen by moon at 7/20/2024, 6:24:00 PM
   */
  @Trace(operationName = "D3执行删除汇报任务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDelReportTaskComRespDto implementDelReportTaskCom(ImplementDelReportTaskComReqDto reqDto){


      //virtualUsage D3查询当前内容汇报任务列表(公共)  71750
      QueryTaskListComRespDto queryTaskListComRespDto = null;
    QueryTaskListComReqDto queryTaskListComReqDto=new QueryTaskListComReqDto();
  queryTaskListComReqDto.setIsComplete("FALSE");//sourceId:1940543_1_71750
queryTaskListComReqDto.setBizSceneCode("REPORTING_TASKS_SCENE");//CUSTOM_CONVENTION//sourceId:1940538_1_71750
queryTaskListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1940535_1_71750
queryTaskListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1940536_1_71750
if(reqDto!=null){
      queryTaskListComReqDto.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1940542_1_71750
queryTaskListComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940533_1_71750
    }

    /*D3查询当前内容汇报任务列表(公共)[8886]   */
    Assert.isNull(queryTaskListComReqDto.getCoordObjectId(),"D3执行删除汇报任务(公共)-D3查询当前内容汇报任务列表(公共)-归属对象ID不能为空",false);
Assert.isNull(queryTaskListComReqDto.getThemeContentId(),"D3执行删除汇报任务(公共)-D3查询当前内容汇报任务列表(公共)-主题内容ID不能为空",false);
Assert.isNull(queryTaskListComReqDto.getIsComplete(),"D3执行删除汇报任务(公共)-D3查询当前内容汇报任务列表(公共)-是否完成不能为空",false);
Assert.isNull(queryTaskListComReqDto.getBizSceneCode(),"D3执行删除汇报任务(公共)-D3查询当前内容汇报任务列表(公共)-业务场景编码不能为空",false);
Assert.isNull(queryTaskListComReqDto.getSpaceId(),"D3执行删除汇报任务(公共)-D3查询当前内容汇报任务列表(公共)-创建于空间ID不能为空",false);
      queryTaskListComRespDto = dashboardTargetContentService.queryTaskListCom(queryTaskListComReqDto)/*vcase invoke isSameApp*/;



if((queryTaskListComRespDto!= null&&  queryTaskListComRespDto.getTaskDataList() !=null && queryTaskListComRespDto.getTaskDataList().size()>0)) {
        //if(D3查询当前内容汇报任务列表(公共).任务列表数据集条数 大于 0)  71751

ImplementDelTargetCycleStageDataComRespDto implementDelTargetCycleStageDataComRespDto = null;
    if(queryTaskListComRespDto !=null){
          ImplementDelTargetCycleStageDataComReqDto implementDelTargetCycleStageDataComReqDto=new ImplementDelTargetCycleStageDataComReqDto();
  if(queryTaskListComRespDto!= null&&  queryTaskListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryTaskListComRespDto.getTaskDataList())){
      implementDelTargetCycleStageDataComReqDto.setCycleStageDataList(queryTaskListComRespDto.getTaskDataList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1940544_1_71752
    }
if(reqDto!=null){
      implementDelTargetCycleStageDataComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940545_1_71752
    }

    /*D3执行删目标内容周期阶段资料(公共)[9981]   */
    Assert.isNull(implementDelTargetCycleStageDataComReqDto.getThemeContentId(),"D3执行删除汇报任务(公共)-D3执行删目标内容周期阶段资料(公共)-主题内容ID不能为空",false);
      implementDelTargetCycleStageDataComRespDto = implementDelTargetCycleStageDataCom(implementDelTargetCycleStageDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
boolean bOOLEAN ;
    if(queryTaskListComRespDto !=null){
          List<String> listString=new ArrayList<>();
  if(queryTaskListComRespDto!= null&&  queryTaskListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryTaskListComRespDto.getTaskDataList())){
      listString = queryTaskListComRespDto.getTaskDataList().stream().map(item->item.getTaskId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1940546_1_71753
    }

    /*3-7-01批量删汇报任务[4806]   */

      bOOLEAN = mOmsTaskService.batchDeleteReportingTask(listString)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
ImplementDelReportTaskComRespDto retData = new ImplementDelReportTaskComRespDto();





return retData;
  }
/**
   * D3执行删目标内容周期阶段资料(公共)[9981]
   * gen by moon at 7/20/2024, 8:42:52 PM
   */
  @Trace(operationName = "D3执行删目标内容周期阶段资料(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDelTargetCycleStageDataComRespDto implementDelTargetCycleStageDataCom(ImplementDelTargetCycleStageDataComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getCycleStageDataList() !=null && reqDto.getCycleStageDataList().size()>0)) {
        //if(D3执行删目标内容周期阶段资料(公共).周期阶段资料列表数据集条数 大于 0)  71743

//ModelCode: circulationCollections
        for (String circulationCollectionsRes: reqDto.getCycleStageDataList()){

BatchDeleteDocRelOrDocComRespDto batchDeleteDocRelOrDocComRespDto = null;
    BatchDeleteDocRelOrDocComReqDto batchDeleteDocRelOrDocComReqDto=new BatchDeleteDocRelOrDocComReqDto();
  batchDeleteDocRelOrDocComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1940054_1_71746
if(circulationCollectionsRes!=null){
      batchDeleteDocRelOrDocComReqDto.setOwnEntityId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1940051_1_71746
    }
if(reqDto!=null){
      batchDeleteDocRelOrDocComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940053_1_71746
    }

    /*D2批量删文档关系或文档(公共)[9755]   */
    Assert.isNull(batchDeleteDocRelOrDocComReqDto.getOwnEntityId(),"D3执行删目标内容周期阶段资料(公共)-D2批量删文档关系或文档(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(batchDeleteDocRelOrDocComReqDto.getThemeContentId(),"D3执行删目标内容周期阶段资料(公共)-D2批量删文档关系或文档(公共)-主题内容ID不能为空",false);
Assert.isNull(batchDeleteDocRelOrDocComReqDto.getSpaceId(),"D3执行删目标内容周期阶段资料(公共)-D2批量删文档关系或文档(公共)-创建于空间ID不能为空",false);
      batchDeleteDocRelOrDocComRespDto = fwCompUnstructuredDataClient.batchDeleteDocRelOrDocCom(batchDeleteDocRelOrDocComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementDelBizAppHypertextContentComRespDto implementDelBizAppHypertextContentComRespDto = null;
    ImplementDelBizAppHypertextContentComReqDto implementDelBizAppHypertextContentComReqDto=new ImplementDelBizAppHypertextContentComReqDto();
  if(circulationCollectionsRes!=null){
      implementDelBizAppHypertextContentComReqDto.setReleationContId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1940062_1_71747
    }
if(reqDto!=null){
      implementDelBizAppHypertextContentComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940063_1_71747
    }

    /*D3执行删业务应用超文本(公共)[9982]   */
    Assert.isNull(implementDelBizAppHypertextContentComReqDto.getReleationContId(),"D3执行删目标内容周期阶段资料(公共)-D3执行删业务应用超文本(公共)-超文本内容关联主键ID不能为空",false);
Assert.isNull(implementDelBizAppHypertextContentComReqDto.getThemeContentId(),"D3执行删目标内容周期阶段资料(公共)-D3执行删业务应用超文本(公共)-主题内容ID不能为空",false);
      implementDelBizAppHypertextContentComRespDto = implementDelBizAppHypertextContentCom(implementDelBizAppHypertextContentComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementDelStandardDataComRespDto implementDelStandardDataComRespDto = null;
    ImplementDelStandardDataComReqDto implementDelStandardDataComReqDto=new ImplementDelStandardDataComReqDto();
  if(circulationCollectionsRes!=null){
      implementDelStandardDataComReqDto.setFromContentEntityId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1940091_1_71748
    }
if(reqDto!=null){
      implementDelStandardDataComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940092_1_71748
    }

    /*D4执行删标准数据(公共)[9983]   */
    Assert.isNull(implementDelStandardDataComReqDto.getFromContentEntityId(),"D3执行删目标内容周期阶段资料(公共)-D4执行删标准数据(公共)-来自内容表主键ID不能为空",false);
Assert.isNull(implementDelStandardDataComReqDto.getThemeContentId(),"D3执行删目标内容周期阶段资料(公共)-D4执行删标准数据(公共)-主题内容ID不能为空",false);
      implementDelStandardDataComRespDto = fwCalcEvaCalcClient.implementDelStandardDataCom(implementDelStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



OmsTspeCycleStageData omsTspeCycleStageData = null;
    QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  if(circulationCollectionsRes!=null){
      queryCycleStageDataDetailReq.setCycleStageDataId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1942899_1_71784
    }
if(reqDto!=null){
      queryCycleStageDataDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1942900_1_71784
    }

    /*3-3-11查当前牌周期阶段资料（用于补删非主周期阶段资料入参）[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getCycleStageDataId(),"D3执行删目标内容周期阶段资料(公共)-3-3-11查当前牌周期阶段资料（用于补删非主周期阶段资料入参）-周期阶段资料记录ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3执行删目标内容周期阶段资料(公共)-3-3-11查当前牌周期阶段资料（用于补删非主周期阶段资料入参）-主题内容ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



boolean bOOLEAN ;
    String string=new String();
  if(circulationCollectionsRes!=null){
      string=circulationCollectionsRes;;//SimpleFieldAssign//sourceId:1942857_1_71785
    }

    /*3-3-11删除汇报主周期阶段资料[4214]   */
    Assert.isNull(string,"D3执行删目标内容周期阶段资料(公共)-3-3-11删除汇报主周期阶段资料-周期阶段资料记录ID不能为空",false);
      bOOLEAN = mOmsTspeCycleStageDataService.deleteCycleStageData(string)/*vcase invoke 本地 method 方法调用;*/;



ImplementCompDelCycleStageDataComRespDto implementCompDelCycleStageDataComRespDto = null;
    if(omsTspeCycleStageData !=null){
          ImplementCompDelCycleStageDataComReqDto implementCompDelCycleStageDataComReqDto=new ImplementCompDelCycleStageDataComReqDto();
  if(omsTspeCycleStageData!=null){
      implementCompDelCycleStageDataComReqDto.setCycleId(omsTspeCycleStageData.getCycleId());//SimpleFieldAssign//sourceId:1942901_1_71786
implementCompDelCycleStageDataComReqDto.setCycleDataObjId(omsTspeCycleStageData.getCycleDataObjId());//SimpleFieldAssign//sourceId:1942902_1_71786
    }
if(reqDto!=null){
      implementCompDelCycleStageDataComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1942903_1_71786
    }

    /*D3执行补删非主周期阶段资料(公共)[9989]   */
    Assert.isNull(implementCompDelCycleStageDataComReqDto.getCycleId(),"D3执行删目标内容周期阶段资料(公共)-D3执行补删非主周期阶段资料(公共)-周期ID不能为空",false);
Assert.isNull(implementCompDelCycleStageDataComReqDto.getCycleDataObjId(),"D3执行删目标内容周期阶段资料(公共)-D3执行补删非主周期阶段资料(公共)-周期资料归属对象ID不能为空",false);
Assert.isNull(implementCompDelCycleStageDataComReqDto.getThemeContentId(),"D3执行删目标内容周期阶段资料(公共)-D3执行补删非主周期阶段资料(公共)-主题内容ID不能为空",false);
      implementCompDelCycleStageDataComRespDto = implementCompDelCycleStageDataCom(implementCompDelCycleStageDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementDelTargetCycleStageDataComRespDto retData = new ImplementDelTargetCycleStageDataComRespDto();





return retData;
  }
/**
   * D3执行补删非主周期阶段资料(公共)[9989]
   * gen by moon at 7/20/2024, 6:27:23 PM
   */
  @Trace(operationName = "D3执行补删非主周期阶段资料(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCompDelCycleStageDataComRespDto implementCompDelCycleStageDataCom(ImplementCompDelCycleStageDataComReqDto reqDto){


      //步骤0: 3-3-11查询周期阶段资料列表 - queryCycleStageDataList
     List<OmsTspeCycleStageData> listOmsTspeCycleStageData =new ArrayList<>();
    QueryCycleStageDataListReq queryCycleStageDataListReq=new QueryCycleStageDataListReq();
  if(reqDto!=null){
      queryCycleStageDataListReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1942799_1
queryCycleStageDataListReq.setCycleDataObjId(reqDto.getCycleDataObjId());//SimpleFieldAssign//sourceId:1942800_1
queryCycleStageDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1942801_1
    }

    /*3-3-11查询周期阶段资料列表[2673]   */
    Assert.isNull(queryCycleStageDataListReq.getCycleId(),"D3执行补删非主周期阶段资料(公共)-3-3-11查询周期阶段资料列表-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getCycleDataObjId(),"D3执行补删非主周期阶段资料(公共)-3-3-11查询周期阶段资料列表-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getThemeContentId(),"D3执行补删非主周期阶段资料(公共)-3-3-11查询周期阶段资料列表-主题内容ID不能为空",false);
      listOmsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataList(queryCycleStageDataListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-3-11批量删周期阶段资料 - batchDeleteCycleStageData
     boolean bOOLEAN ;
    if(listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&& listOmsTspeCycleStageData.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsTspeCycleStageData!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&&  listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)){
      listString = listOmsTspeCycleStageData.stream().map(item->item.getCycleStageDataId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1942742_1
    }

    /*3-3-11批量删周期阶段资料[4220]   */

      bOOLEAN = mOmsTspeCycleStageDataService.batchDeleteCycleStageData(listString)/*vcase invoke 本地 method 方法调用;*/;



           }

ImplementCompDelCycleStageDataComRespDto retData = new ImplementCompDelCycleStageDataComRespDto();





return retData;
  }
/**
   * D3查询汇报任务树筛选条件列表[9997]
   * gen by moon at 7/24/2024, 3:08:10 AM
   */
  @Trace(operationName = "D3查询汇报任务树筛选条件列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryReportTaskTreeFilterListRespDto queryReportTaskTreeFilterList(QueryReportTaskTreeFilterListReqDto reqDto){


      QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto_1 =null;
//步骤0: D3查询被评目标周期列表(公共) - queryEvaTargetCycleListCom
     QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1944019_1
queryEvaTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1944020_1
queryEvaTargetCycleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1944034_1
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1944021_1
queryEvaTargetCycleListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1949999_1
queryEvaTargetCycleListComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1944024_1
queryEvaTargetCycleListComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1950000_1
queryEvaTargetCycleListComReqDto.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1950001_1
      queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1944027_1
    }

    /*D3查询被评目标周期列表(公共)[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(),"D3查询汇报任务树筛选条件列表-D3查询被评目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3查询汇报任务树筛选条件列表-D3查询被评目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentTypeCode(),"D3查询汇报任务树筛选条件列表-D3查询被评目标周期列表(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3查询汇报任务树筛选条件列表-D3查询被评目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getSubjectLifeCycle(),"D3查询汇报任务树筛选条件列表-D3查询被评目标周期列表(公共)-主体生命周期不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


      queryEvaTargetCycleListComRespDto_1 = queryEvaTargetCycleListComRespDto;

QueryReportTaskTreeFilterListRespDto retData = new QueryReportTaskTreeFilterListRespDto();
  if(queryEvaTargetCycleListComRespDto_1!=null){
      retData.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1944037_1
    }




return retData;
  }
/**
   * D3查询汇报任务归属周期筛选条件列表[10000]
   * gen by moon at 7/20/2024, 11:06:30 PM
   */
  @Trace(operationName = "D3查询汇报任务归属周期筛选条件列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryReportTaskAttributionCycleFilterListRespDto queryReportTaskAttributionCycleFilterList(QueryReportTaskAttributionCycleFilterListReqDto reqDto){


      List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle_1 =new ArrayList<>();
List<OmsCycle> listOmsCycle_1 =new ArrayList<>();
//步骤0: 3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表 - queryTargetBelongCycleByLeStartOrGeEndTimeSorList
     List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    QueryTargetBelongCycleByLeStartOrGeEndTimeSorListReq queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq=new QueryTargetBelongCycleByLeStartOrGeEndTimeSorListReq();
  queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1944488_1
queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1944489_1
queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1944490_1
if(reqDto!=null){
      queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1944499_1
queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1944491_1
    }

    /*3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表[10001]   */
    Assert.isNull(queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.getEvaObjTypeCode(),"D3查询汇报任务归属周期筛选条件列表-3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.getCycleStartTime(),"D3查询汇报任务归属周期筛选条件列表-3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.getTargetCycleContentTypeCode(),"D3查询汇报任务归属周期筛选条件列表-3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq.getEvaluationTemplateId(),"D3查询汇报任务归属周期筛选条件列表-3-3-09-07查询目标归属周期（小于等于开始时间或小于等于结束时间）列表-冗余评价模板ID不能为空",false);
      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByLeStartOrGeEndTimeSorList(queryTargetBelongCycleByLeStartOrGeEndTimeSorListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetAttributionCycle_1 = listOmsTargetAttributionCycle;

//步骤1: 3-4-04批量查周期列表 - batchQueryCycle
     List<OmsCycle> listOmsCycle =new ArrayList<>();
    if(listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&& listOmsTargetAttributionCycle.size()>0 ){
          BatchQueryCycleReq batchQueryCycleReq=new BatchQueryCycleReq();
  if(listOmsTargetAttributionCycle!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&&  listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)){
      batchQueryCycleReq.setCycleList(listOmsTargetAttributionCycle.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1944493_1
    }

    /*3-4-04批量查周期列表[2249]   */

      listOmsCycle = mOmsCycleService.batchQueryCycle(batchQueryCycleReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsCycle_1 = listOmsCycle;
           }

QueryReportTaskAttributionCycleFilterListRespDto retData = new QueryReportTaskAttributionCycleFilterListRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsTargetAttributionCycle_1!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_1) && !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_1) ){
          for (OmsTargetAttributionCycle omsTargetAttributionCycle : listOmsTargetAttributionCycle_1) {
              TargetBelongCycleDto retElm = new TargetBelongCycleDto();
             retElm.setCycleId(omsTargetAttributionCycle.getCycleId());//SimpleFieldAssign//sourceId:397194_2
              retData.getTargetBelongCycleList().add(retElm);
               if(listOmsCycle_1!= null&& !CollectionUtil.isEmpty(listOmsCycle_1)){
          for (OmsCycle omsCycle : listOmsCycle_1) {
                if (omsCycle.getCycleId().equals(omsTargetAttributionCycle.getCycleId())) {
                 retElm.setCycleStandardName(omsCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:397195_2
                }
            }
          }

          }
        }//sourceId:1944501_1




return retData;
  }
/**
   * D3查询汇报给我下属筛选条件列表[9999]
   * gen by moon at 7/25/2024, 10:01:10 PM
   */
  @Trace(operationName = "D3查询汇报给我下属筛选条件列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryReportToMeSubordinateFilterListRespDto queryReportToMeSubordinateFilterList(QueryReportToMeSubordinateFilterListReqDto reqDto){


BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto_1 =null;

//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1944472_1
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询汇报给我下属筛选条件列表-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementFiveReceivingField(receptionServiceReq);




//步骤1: D3查询我下属负责的小圈子列表(公共) - querySubordinateChargeSmallCircleListCom
     QuerySubordinateChargeSmallCircleListComRespDto querySubordinateChargeSmallCircleListComRespDto = null;
    QuerySubordinateChargeSmallCircleListComReqDto querySubordinateChargeSmallCircleListComReqDto=new QuerySubordinateChargeSmallCircleListComReqDto();
  querySubordinateChargeSmallCircleListComReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1944554_1
querySubordinateChargeSmallCircleListComReqDto.setRoleCode("DIRECTOR");//CUSTOM_CONVENTION//sourceId:1944555_1
querySubordinateChargeSmallCircleListComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1944556_1
querySubordinateChargeSmallCircleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1944561_1
if(reqDto!=null){
      querySubordinateChargeSmallCircleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1944557_1
    }

    /*D3查询我下属负责的小圈子列表（包含自己）[8805]   */
    Assert.isNull(querySubordinateChargeSmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询汇报给我下属筛选条件列表-D3查询我下属负责的小圈子列表（包含自己）-身份人员ID不能为空",false);
Assert.isNull(querySubordinateChargeSmallCircleListComReqDto.getRoleCode(),"D3查询汇报给我下属筛选条件列表-D3查询我下属负责的小圈子列表（包含自己）-角色标识不能为空",false);
Assert.isNull(querySubordinateChargeSmallCircleListComReqDto.getUseScene(),"D3查询汇报给我下属筛选条件列表-D3查询我下属负责的小圈子列表（包含自己）-虚拟组织使用场景不能为空",false);
Assert.isNull(querySubordinateChargeSmallCircleListComReqDto.getEvaluationTemplateId(),"D3查询汇报给我下属筛选条件列表-D3查询我下属负责的小圈子列表（包含自己）-归属对象ID不能为空",false);
Assert.isNull(querySubordinateChargeSmallCircleListComReqDto.getSpaceId(),"D3查询汇报给我下属筛选条件列表-D3查询我下属负责的小圈子列表（包含自己）-创建于空间ID不能为空",false);
      querySubordinateChargeSmallCircleListComRespDto = smallCircleCommonService.querySubordinateChargeSmallCircleListCom(querySubordinateChargeSmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2执行数据集减一条记录(公共) - implementDataSubtractOneCom
     ImplementDataSubtractOneComRespDto implementDataSubtractOneComRespDto = null;
    if(querySubordinateChargeSmallCircleListComRespDto !=null){
          ImplementDataSubtractOneComReqDto implementDataSubtractOneComReqDto=new ImplementDataSubtractOneComReqDto();
  implementDataSubtractOneComReqDto.setCustomField(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1950883_1
if(querySubordinateChargeSmallCircleListComRespDto!=null){
      implementDataSubtractOneComReqDto.setDataSubtractOneList(querySubordinateChargeSmallCircleListComRespDto.getIdentityDudepSubordinateChargeSmallCircleList());//list-field-assign//sourceId:1950884_1
    }

    /*D2下属身份人员列表去除自己(公共)[5415]   */
    Assert.isNull(implementDataSubtractOneComReqDto.getCustomField(),"D3查询汇报给我下属筛选条件列表-D2下属身份人员列表去除自己(公共)-自定义字段不能为空",false);
      implementDataSubtractOneComRespDto = fwCompInterfaceModeClient.implementDataSubtractOneCom(implementDataSubtractOneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤3: D1批量查询个人资料By身份人员(公共) - batchQueryUserinfoByMemberCom
     BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto = null;
    if(implementDataSubtractOneComRespDto !=null){
          BatchQueryUserinfoByMemberComReqDto batchQueryUserinfoByMemberComReqDto=new BatchQueryUserinfoByMemberComReqDto();
  batchQueryUserinfoByMemberComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1944563_1
if(implementDataSubtractOneComRespDto!=null){
      batchQueryUserinfoByMemberComReqDto.setBeginMemberList(implementDataSubtractOneComRespDto.getDataSubtractOneList());//list-field-assign//sourceId:1944562_1
    }

    /*D1批量查询个人资料By身份人员(公共)[9064]   */
    Assert.isNull(batchQueryUserinfoByMemberComReqDto.getSpaceId(),"D3查询汇报给我下属筛选条件列表-D1批量查询个人资料By身份人员(公共)-创建于空间ID不能为空",false);
      batchQueryUserinfoByMemberComRespDto = fwBaseDashboardOrgClient.batchQueryUserinfoByMemberCom(batchQueryUserinfoByMemberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryUserinfoByMemberComRespDto_1 = batchQueryUserinfoByMemberComRespDto;
           }

QueryReportToMeSubordinateFilterListRespDto retData = new QueryReportToMeSubordinateFilterListRespDto();

      if(batchQueryUserinfoByMemberComRespDto_1!=null){
          retData.setSubordinateChargeSmallCircleList(batchQueryUserinfoByMemberComRespDto_1.getBeginMemberList().stream().map(item -> BeanUtil.toBean(item, SubordinateChargeSmallCircleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1661556_1

      }



return retData;
  }
/**
   * D3查询我相关汇报任务部门筛选条件列表[10004]
   * gen by moon at 7/21/2024, 2:40:23 PM
   */
  @Trace(operationName = "D3查询我相关汇报任务部门筛选条件列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRelatedMeReportTaskDeptFilterListRespDto queryRelatedMeReportTaskDeptFilterList(QueryRelatedMeReportTaskDeptFilterListReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1945019_1
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询我相关汇报任务部门筛选条件列表-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementFiveReceivingField(receptionServiceReq);




//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1945003_1
queryIdentitySmallCircleListComReqDto.setIsUpperLowerLevels("FALSE");//sourceId:1945018_1
queryIdentitySmallCircleListComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1945006_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1945009_1
queryIdentitySmallCircleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1945015_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1945007_1
    }

    /*D3查询当前身份人员非上下级关系小圈子列表(公共)[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getEvaluationTemplateId(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-归属对象ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsUpperLowerLevels(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-是否上下级关系不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询我相关汇报任务部门筛选条件列表-D3查询当前身份人员非上下级关系小圈子列表(公共)-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-6-03批量查虚拟成员部门 - batchQueryVirtualOrgMemberDept
     List<OmsVirtualOrgMemberDept> listOmsVirtualOrgMemberDept =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryVirtualOrgMemberDeptReq batchQueryVirtualOrgMemberDeptReq=new BatchQueryVirtualOrgMemberDeptReq();
  batchQueryVirtualOrgMemberDeptReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1945044_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryVirtualOrgMemberDeptReq.setVirtualOrgMemberDeptList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> BeanUtil.toBean(item, VirtualOrgMemberDeptDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1945039_1
    }
if(reqDto!=null){
      batchQueryVirtualOrgMemberDeptReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1945050_1
    }

    /*3-6-03批量查虚拟成员部门[2647]   */
    Assert.isNull(batchQueryVirtualOrgMemberDeptReq.getEvaluationTemplateId(),"D3查询我相关汇报任务部门筛选条件列表-3-6-03批量查虚拟成员部门-归属对象ID不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberDeptReq.getSubjectLifeCycle(),"D3查询我相关汇报任务部门筛选条件列表-3-6-03批量查虚拟成员部门-主体生命周期不能为空",false);
      listOmsVirtualOrgMemberDept = mOmsVirtualOrgMemberDeptService.batchQueryVirtualOrgMemberDept(batchQueryVirtualOrgMemberDeptReq)/*vcase invoke 本地 method 方法调用;*/;



           }

//步骤3: D2执行多字段数据集记录去重(公共) - implementManyFieldsDataSetDuplicateRemovalCom
     ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
    if(listOmsVirtualOrgMemberDept !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)&& listOmsVirtualOrgMemberDept.size()>0 ){
          ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto=new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
  if(listOmsVirtualOrgMemberDept!= null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)&&  listOmsVirtualOrgMemberDept !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)){
      implementManyFieldsDataSetDuplicateRemovalComReqDto.setDataSetDuplicateRemovalList(//objList-to-objLists
        listOmsVirtualOrgMemberDept.stream().map(item -> {
      DataSetDuplicateRemovalDto elm = new DataSetDuplicateRemovalDto();
      elm.setCommPrimaryKey(item.getDeptId());//SimpleFieldAssign//sourceId:397361_2
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1945051_1
    }

    /*D2部门数据集记录去重(公共)[7323]   */

      implementManyFieldsDataSetDuplicateRemovalComRespDto = fwCompInterfaceModeClient.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤4: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
    if(implementManyFieldsDataSetDuplicateRemovalComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(implementManyFieldsDataSetDuplicateRemovalComRespDto!= null&&  implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() !=null&& !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())){
      receptionServiceReq_1.setDeptList(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item->item.getCommPrimaryKey())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1945486_1
    }

    /*M3接收部门数据集出参[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes_1 = nbEvaCalc.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

QueryRelatedMeReportTaskDeptFilterListRespDto retData = new QueryRelatedMeReportTaskDeptFilterListRespDto();
  if(receptionServiceRes_2!=null){
      retData.setDeptList(receptionServiceRes_2.getDeptList());//list-field-assign//sourceId:1945487_1
    }




return retData;
  }
/**
   * D3获取自动汇报目标归属周期(公共)[10103]
   * gen by moon at 8/19/2024, 10:24:17 PM
   */
  @Trace(operationName = "D3获取自动汇报目标归属周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainAtuoReportTargetBelongCycleComRespDto obtainAtuoReportTargetBelongCycleCom(ObtainAtuoReportTargetBelongCycleComReqDto reqDto){


      QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto_1 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1973874_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1973875_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1973876_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleStageDataId(),"D3获取自动汇报目标归属周期(公共)-M3接收入参字段-周期阶段资料记录ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3获取自动汇报目标归属周期(公共)-M3接收入参字段-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3获取自动汇报目标归属周期(公共)-M3接收入参字段-主树被评对象类型编码不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);




//步骤1: D3-3查询周期阶段资料详情(公共) - queryCycleStageDataDetailCom
     QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  queryCycleStageDataDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1973400_1
if(reqDto!=null){
      queryCycleStageDataDetailComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1973397_1
    }

    /*D3-3查询周期阶段资料详情(公共)[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleStageDataId(),"D3获取自动汇报目标归属周期(公共)-D3-3查询周期阶段资料详情(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSpaceId(),"D3获取自动汇报目标归属周期(公共)-D3-3查询周期阶段资料详情(公共)-创建于空间ID不能为空",false);
      queryCycleStageDataDetailComRespDto = cycleStageDataService.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D3查目标归属周期详情(公共) - queryTargetBeCycleDetailCom
     QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto = null;
    if(queryCycleStageDataDetailComRespDto !=null){
          QueryTargetBeCycleDetailComReqDto queryTargetBeCycleDetailComReqDto=new QueryTargetBeCycleDetailComReqDto();
  if(reqDto!=null){
      queryTargetBeCycleDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1973434_1
queryTargetBeCycleDetailComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1973435_1
    }
if(queryCycleStageDataDetailComRespDto!=null){
      queryTargetBeCycleDetailComReqDto.setCycleId(queryCycleStageDataDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1973433_1
queryTargetBeCycleDetailComReqDto.setEntityId(queryCycleStageDataDetailComRespDto.getCycleDataObjId());//SimpleFieldAssign//sourceId:1973404_1
queryTargetBeCycleDetailComReqDto.setParentSubMidCycleType(queryCycleStageDataDetailComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1973405_1
queryTargetBeCycleDetailComReqDto.setEvaluationTemplateId(queryCycleStageDataDetailComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:1973406_1
    }

    /*D3查目标归属周期详情(公共)[9544]   */
    Assert.isNull(queryTargetBeCycleDetailComReqDto.getEvaObjEntityId(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEvaObjTypeCode(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getCycleId(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-归属周期ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEntityId(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getParentSubMidCycleType(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEvaluationTemplateId(),"D3获取自动汇报目标归属周期(公共)-D3查目标归属周期详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetBeCycleDetailComRespDto = targetCalcService.queryTargetBeCycleDetailCom(queryTargetBeCycleDetailComReqDto)/*vcase invoke isSameApp*/;


      queryTargetBeCycleDetailComRespDto_1 = queryTargetBeCycleDetailComRespDto;
           }

ObtainAtuoReportTargetBelongCycleComRespDto retData = new ObtainAtuoReportTargetBelongCycleComRespDto();
  if(queryTargetBeCycleDetailComRespDto_1!=null){
      retData.setEvaProgressCalcCode(queryTargetBeCycleDetailComRespDto_1.getEvaProgressCalcCode());//SimpleFieldAssign//sourceId:1976315_1
retData.setEvaActualCalcCode(queryTargetBeCycleDetailComRespDto_1.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1976316_1
retData.setProgressValueElement(queryTargetBeCycleDetailComRespDto_1.getProgressValueElement());//SimpleFieldAssign//sourceId:1976484_1
retData.setActualValueElement(queryTargetBeCycleDetailComRespDto_1.getActualValueElement());//SimpleFieldAssign//sourceId:1976485_1
retData.setBudgetAmountElement(queryTargetBeCycleDetailComRespDto_1.getBudgetAmountElement());//SimpleFieldAssign//sourceId:1976486_1
retData.setTargetAttributionCycleId(queryTargetBeCycleDetailComRespDto_1.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1973880_1
retData.setPreviousCycleId(queryTargetBeCycleDetailComRespDto_1.getPreviousCycleId());//SimpleFieldAssign//sourceId:1973881_1
retData.setLastEvaObjTargetCycleId(queryTargetBeCycleDetailComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1973882_1
retData.setCycleId(queryTargetBeCycleDetailComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1973883_1
retData.setCycleStartTime(queryTargetBeCycleDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1973884_1
retData.setCycleEndTime(queryTargetBeCycleDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1973885_1
retData.setCycleTypeCode(queryTargetBeCycleDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1973886_1
retData.setCycleTypeInstanceCode(queryTargetBeCycleDetailComRespDto_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1973887_1
retData.setTargetCycleId(queryTargetBeCycleDetailComRespDto_1.getTargetCycleId());//SimpleFieldAssign//sourceId:1973888_1
retData.setParentSubMidCycleType(queryTargetBeCycleDetailComRespDto_1.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1973889_1
retData.setStandardDataCalcCycleModel(queryTargetBeCycleDetailComRespDto_1.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1973890_1
retData.setSubCycleCalcModelId(queryTargetBeCycleDetailComRespDto_1.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:1973891_1
retData.setMidCycleCalcModelId(queryTargetBeCycleDetailComRespDto_1.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:1973892_1
retData.setParentCycleCalcModelId(queryTargetBeCycleDetailComRespDto_1.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:1973893_1
retData.setEvaObjEntityId(queryTargetBeCycleDetailComRespDto_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1973894_1
retData.setEvaObjTypeCode(queryTargetBeCycleDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1973895_1
retData.setEvaObjTargetCycleCode(queryTargetBeCycleDetailComRespDto_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1973896_1
retData.setFromContentTableTypeCode(queryTargetBeCycleDetailComRespDto_1.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1976629_1
retData.setFromContentEntityId(queryTargetBeCycleDetailComRespDto_1.getFromContentEntityId());//SimpleFieldAssign//sourceId:1976630_1
retData.setTableTypeCode(queryTargetBeCycleDetailComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1976631_1
retData.setEntityId(queryTargetBeCycleDetailComRespDto_1.getEntityId());//SimpleFieldAssign//sourceId:1973897_1
retData.setBelongToContentTypeCode(queryTargetBeCycleDetailComRespDto_1.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1973898_1
retData.setTargetCycleContentTypeCode(queryTargetBeCycleDetailComRespDto_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1976504_1
retData.setBelongToContentId(queryTargetBeCycleDetailComRespDto_1.getBelongToContentId());//SimpleFieldAssign//sourceId:1973899_1
retData.setTargetValueType(queryTargetBeCycleDetailComRespDto_1.getTargetValueType());//SimpleFieldAssign//sourceId:1976970_1
retData.setCategoryTableTypeCode(queryTargetBeCycleDetailComRespDto_1.getCategoryTableTypeCode());//SimpleFieldAssign//sourceId:1976632_1
retData.setOneLevelCategoryId(queryTargetBeCycleDetailComRespDto_1.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1973900_1
retData.setPersonLiableTypeCode(queryTargetBeCycleDetailComRespDto_1.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1973901_1
retData.setPersonLiableObjId(queryTargetBeCycleDetailComRespDto_1.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1973902_1
retData.setBizRoleObjId(queryTargetBeCycleDetailComRespDto_1.getBizRoleObjId());//SimpleFieldAssign//sourceId:1973903_1
retData.setBizRoleObjCode(queryTargetBeCycleDetailComRespDto_1.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1973904_1
retData.setBizRoleObjName(queryTargetBeCycleDetailComRespDto_1.getBizRoleObjName());//SimpleFieldAssign//sourceId:1973905_1
retData.setBelongToPersonalIdentityId(queryTargetBeCycleDetailComRespDto_1.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1973906_1
retData.setIsWorkCycleData(queryTargetBeCycleDetailComRespDto_1.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1973907_1
retData.setWorkCycleUpdateSlice(queryTargetBeCycleDetailComRespDto_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1973908_1
retData.setIsLastCycle(queryTargetBeCycleDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1973909_1
retData.setRecentlyNewCycleId(queryTargetBeCycleDetailComRespDto_1.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:1973910_1
retData.setEvaluationTemplateId(queryTargetBeCycleDetailComRespDto_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1973911_1
retData.setBelongToPersonalIdentityTypeCode(queryTargetBeCycleDetailComRespDto_1.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1973912_1
retData.setDashboradPrimaryDeptId(queryTargetBeCycleDetailComRespDto_1.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:1973913_1
retData.setDashboradBasicDeptId(queryTargetBeCycleDetailComRespDto_1.getDashboradBasicDeptId());//SimpleFieldAssign//sourceId:1973914_1
retData.setDashboradOriginalRoleMemberId(queryTargetBeCycleDetailComRespDto_1.getDashboradOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1973915_1
retData.setDashboradDirectorOriginalRoleMemberId(queryTargetBeCycleDetailComRespDto_1.getDashboradDirectorOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1973916_1
retData.setDashboradDeptLeaderOriginalRoleMemberId(queryTargetBeCycleDetailComRespDto_1.getDashboradDeptLeaderOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1973917_1
retData.setEvaReportScoreCalcCode(queryTargetBeCycleDetailComRespDto_1.getEvaReportScoreCalcCode());//SimpleFieldAssign//sourceId:1978664_1
retData.setRankOrDownCalc(queryTargetBeCycleDetailComRespDto_1.getRankOrDownCalc());//SimpleFieldAssign//sourceId:1978665_1
retData.setSubAndObjModel(queryTargetBeCycleDetailComRespDto_1.getSubAndObjModel());//SimpleFieldAssign//sourceId:1978666_1
retData.setEvaWeightScore(queryTargetBeCycleDetailComRespDto_1.getEvaWeightScore());//SimpleFieldAssign//sourceId:1978667_1
retData.setEvaTargetStartValue(queryTargetBeCycleDetailComRespDto_1.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:1978668_1
retData.setEvaTargetValue(queryTargetBeCycleDetailComRespDto_1.getEvaTargetValue());//SimpleFieldAssign//sourceId:1978669_1
retData.setEvaTargetDiagnosticValue(queryTargetBeCycleDetailComRespDto_1.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:1978670_1
    }




return retData;
  }
/**
   * D3执行自动汇报元素公式校验(公共)[10104]
   * gen by moon at 8/19/2024, 2:19:35 AM
   */
  @Trace(operationName = "D3执行自动汇报元素公式校验(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAtuoReportElementFormulaVerifyComRespDto implementAtuoReportElementFormulaVerifyCom(ImplementAtuoReportElementFormulaVerifyComReqDto reqDto){


      if((reqDto!= null&& reqDto.getEvaProgressCalcCode() != null &&reqDto!= null&& reqDto.getProgressValueElement() == 0L)) {
        //if((D3执行自动汇报元素公式校验(公共).主树进度值计算公式标识 值不等于空  and D3执行自动汇报元素公式校验(公共).汇报进度值元素 等于 0))  72255

//异常结束 72278
      throw new BizException("C10100506","对不起！进度值公式与进度值元素0不匹配~",false);
      }
if((reqDto!= null&& reqDto.getEvaActualCalcCode() != null &&reqDto!= null&& reqDto.getActualValueElement() == 0L&&!(reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("PROGRESS")))) {
        //if((D3执行自动汇报元素公式校验(公共).主树实际值计算公式标识 值不等于空  and D3执行自动汇报元素公式校验(公共).汇报实际值元素 等于 0 and D3执行自动汇报元素公式校验(公共).冗余指标业务类型 不等于 进度型))  72267

//异常结束 72279
      throw new BizException("C10100507","对不起！实际值公式与实际值元素0不匹配~	",false);
      }
if((reqDto!= null&& reqDto.getEvaProgressCalcCode() == null )&&(reqDto!= null&& reqDto.getProgressValueElement() == 1L||reqDto!= null&& reqDto.getProgressValueElement() == 2L)) {
        //if(D3执行自动汇报元素公式校验(公共).主树进度值计算公式标识 值等于空  and (D3执行自动汇报元素公式校验(公共).汇报进度值元素 等于 1 or D3执行自动汇报元素公式校验(公共).汇报进度值元素 等于 2))  72273

//异常结束 72280
      throw new BizException("C10100508","对不起！进度值公式与进度值元素1或2不匹配~",false);
      }
if((reqDto!= null&& reqDto.getEvaActualCalcCode() == null )&&(reqDto!= null&& reqDto.getActualValueElement() == 1L||reqDto!= null&& reqDto.getActualValueElement() == 2L)) {
        //if(D3执行自动汇报元素公式校验(公共).主树实际值计算公式标识 值等于空  and (D3执行自动汇报元素公式校验(公共).汇报实际值元素 等于 1 or D3执行自动汇报元素公式校验(公共).汇报实际值元素 等于 2))  72272

//异常结束 72282
      throw new BizException("C10100509","对不起！实际值公式与实际值元素1或2不匹配~	",false);
      }
if((reqDto!= null&& reqDto.getProgressValueElement() != null &&reqDto!= null&& reqDto.getProgressValueElement() == 2L)) {
        //if((D3执行自动汇报元素公式校验(公共).汇报进度值元素 值不等于空  and D3执行自动汇报元素公式校验(公共).汇报进度值元素 等于 2))  72269

//异常结束 72283
      throw new BizException("C10100503","对不起！进度值需要人工填报，不允许自动汇报~",false);
      }
if((reqDto!= null&& reqDto.getActualValueElement() != null &&reqDto!= null&& reqDto.getActualValueElement() == 2L)) {
        //if((D3执行自动汇报元素公式校验(公共).汇报实际值元素 值不等于空  and D3执行自动汇报元素公式校验(公共).汇报实际值元素 等于 2))  72275

//异常结束 72284
      throw new BizException("C10100504","对不起！实际值需要人工填报，不允许自动汇报~",false);
      }
if((reqDto!= null&& reqDto.getBudgetAmountElement() != null &&reqDto!= null&& reqDto.getBudgetAmountElement() == 2L)) {
        //if((D3执行自动汇报元素公式校验(公共).汇报预算元素 值不等于空  and D3执行自动汇报元素公式校验(公共).汇报预算元素 等于 2))  72277

//异常结束 72285
      throw new BizException("C10100505","对不起！费用支出需要人工填报，不允许自动汇报~",false);
      }
ImplementAtuoReportElementFormulaVerifyComRespDto retData = new ImplementAtuoReportElementFormulaVerifyComRespDto();





return retData;
  }
/**
   * D3查询未完成汇报任务列表(公共)[10140]
   * gen by moon at 8/21/2024, 2:58:50 PM
   */
  @Trace(operationName = "D3查询未完成汇报任务列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryIncompleteReportTaskListComRespDto queryIncompleteReportTaskListCom(QueryIncompleteReportTaskListComReqDto reqDto){


      List<OmsTspeCycleStageData> listOmsTspeCycleStageData_1 =new ArrayList<>();
List<OmsTask> listOmsTask_1 =new ArrayList<>();
BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto_1 =null;
//virtualUsage D3查询负责人小圈子列表(获取目标内容范围)  72402
      QueryVirtualOrgMemListComRespDto queryVirtualOrgMemListComRespDto = null;
    QueryVirtualOrgMemListComReqDto queryVirtualOrgMemListComReqDto=new QueryVirtualOrgMemListComReqDto();
  queryVirtualOrgMemListComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1981299_1_72402
queryVirtualOrgMemListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1981300_1_72402
if(reqDto!=null){
      queryVirtualOrgMemListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1981297_1_72402
queryVirtualOrgMemListComReqDto.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1981305_1_72402
queryVirtualOrgMemListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1981306_1_72402
queryVirtualOrgMemListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1981298_1_72402
    }

    /*D3查询负责人小圈子列表(获取目标内容范围)[8698]   */
    Assert.isNull(queryVirtualOrgMemListComReqDto.getUseScene(),"D3查询未完成汇报任务列表(公共)-D3查询负责人小圈子列表(获取目标内容范围)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryVirtualOrgMemListComReqDto.getSubjectLifeCycle(),"D3查询未完成汇报任务列表(公共)-D3查询负责人小圈子列表(获取目标内容范围)-主体生命周期不能为空",false);
      queryVirtualOrgMemListComRespDto = virtualOrgService.queryVirtualOrgMemListCom(queryVirtualOrgMemListComReqDto)/*vcase invoke isSameApp*/;



if((queryVirtualOrgMemListComRespDto!= null&&  queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList() !=null && queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList().size()>0)) {
        //if(D3查询负责人小圈子列表(获取目标内容范围).虚拟组织成员列表数据集条数 大于 0)  72403

List<OmsTspeCycleStageData> listOmsTspeCycleStageData =new ArrayList<>();
    if(queryVirtualOrgMemListComRespDto !=null){
          BatchQueryCycleStageDataByBelongContReq batchQueryCycleStageDataByBelongContReq=new BatchQueryCycleStageDataByBelongContReq();
  batchQueryCycleStageDataByBelongContReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1981318_1_72404
batchQueryCycleStageDataByBelongContReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:1981319_1_72404
batchQueryCycleStageDataByBelongContReq.setCyclePurposeTypeCode("OBS_TAR_REP");//sourceId:1981321_1_72404
batchQueryCycleStageDataByBelongContReq.setSubjectLifeCycle("EDITING");//sourceId:1981324_1_72404
batchQueryCycleStageDataByBelongContReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1981325_1_72404
if(queryVirtualOrgMemListComRespDto!= null&&  queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList())){
      batchQueryCycleStageDataByBelongContReq.setCycleStageDataList(queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981317_1_72404
    }
if(reqDto!=null){
      batchQueryCycleStageDataByBelongContReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1981323_1_72404
    }

    /*3-3-11批量查询周期阶段资料By归属内容[10141]   */
    Assert.isNull(batchQueryCycleStageDataByBelongContReq.getCycleDataTypeCode(),"D3查询未完成汇报任务列表(公共)-3-3-11批量查询周期阶段资料By归属内容-周期阶段资料类型编码不能为空",false);
Assert.isNull(batchQueryCycleStageDataByBelongContReq.getStageContentType(),"D3查询未完成汇报任务列表(公共)-3-3-11批量查询周期阶段资料By归属内容-内容性质类型编码不能为空",false);
Assert.isNull(batchQueryCycleStageDataByBelongContReq.getCyclePurposeTypeCode(),"D3查询未完成汇报任务列表(公共)-3-3-11批量查询周期阶段资料By归属内容-周期资料用途类型编码不能为空",false);
Assert.isNull(batchQueryCycleStageDataByBelongContReq.getSubjectLifeCycle(),"D3查询未完成汇报任务列表(公共)-3-3-11批量查询周期阶段资料By归属内容-主体生命周期不能为空",false);
Assert.isNull(batchQueryCycleStageDataByBelongContReq.getSpaceId(),"D3查询未完成汇报任务列表(公共)-3-3-11批量查询周期阶段资料By归属内容-创建于空间ID不能为空",false);
      listOmsTspeCycleStageData = mOmsTspeCycleStageDataService.batchQueryCycleStageDataByBelongCont(batchQueryCycleStageDataByBelongContReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTspeCycleStageData_1 = listOmsTspeCycleStageData;
           }
List<OmsTask> listOmsTask =new ArrayList<>();
    if(listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&& listOmsTspeCycleStageData.size()>0 ){
          BatchQueryTaskReq batchQueryTaskReq=new BatchQueryTaskReq();
  batchQueryTaskReq.setIsComplete("FALSE");//sourceId:1981332_1_72405
batchQueryTaskReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1981336_1_72405
batchQueryTaskReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1981340_1_72405
if(listOmsTspeCycleStageData!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&&  listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)){
      batchQueryTaskReq.setReportingTaskList(listOmsTspeCycleStageData.stream().map(item->item.getTaskId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981327_1_72405
    }

    /*3-7-01批量查任务列表[2566]   */
    Assert.isNull(batchQueryTaskReq.getIsComplete(),"D3查询未完成汇报任务列表(公共)-3-7-01批量查任务列表-是否完成不能为空",false);
Assert.isNull(batchQueryTaskReq.getSubjectLifeCycle(),"D3查询未完成汇报任务列表(公共)-3-7-01批量查任务列表-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskReq.getSpaceId(),"D3查询未完成汇报任务列表(公共)-3-7-01批量查任务列表-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTask(batchQueryTaskReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }
BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto = null;
    if(listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&& listOmsTspeCycleStageData.size()>0 ){
          BatchQueryVirtualCircleByContComReqDto batchQueryVirtualCircleByContComReqDto=new BatchQueryVirtualCircleByContComReqDto();
  if(listOmsTspeCycleStageData!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&&  listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)){
      batchQueryVirtualCircleByContComReqDto.setTargetContentList(listOmsTspeCycleStageData.stream().map(item->item.getBelongToContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981844_1_72412
    }

    /*D3批量查询虚拟圈子By内容(公共)[10142]   */

      batchQueryVirtualCircleByContComRespDto = virtualOrgService.batchQueryVirtualCircleByContCom(batchQueryVirtualCircleByContComReqDto)/*vcase invoke isSameApp*/;


      batchQueryVirtualCircleByContComRespDto_1 = batchQueryVirtualCircleByContComRespDto;
           }
      }
QueryIncompleteReportTaskListComRespDto retData = new QueryIncompleteReportTaskListComRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsTspeCycleStageData_1!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData_1) && !CollectionUtil.isEmpty(listOmsTspeCycleStageData_1) ){
          for (OmsTspeCycleStageData omsTspeCycleStageData : listOmsTspeCycleStageData_1) {
              TaskDataDto retElm = new TaskDataDto();
             retElm.setTaskId(omsTspeCycleStageData.getTaskId());//SimpleFieldAssign//sourceId:409853_2
retElm.setCycleStandardName(omsTspeCycleStageData.getCycleStandardName());//SimpleFieldAssign//sourceId:409854_2
retElm.setBelongToContentId(omsTspeCycleStageData.getBelongToContentId());//SimpleFieldAssign//sourceId:409855_2
              retData.getTaskDataList().add(retElm);
               if(listOmsTask_1!= null&& !CollectionUtil.isEmpty(listOmsTask_1)){
          for (OmsTask omsTask : listOmsTask_1) {
                if (omsTask.getTaskId().equals(omsTspeCycleStageData.getTaskId())) {
                 retElm.setTaskName(omsTask.getTaskName());//SimpleFieldAssign//sourceId:409856_2
retElm.setStateCode(omsTask.getStateCode());//SimpleFieldAssign//sourceId:409857_2
                }
            }
          }

 if(batchQueryVirtualCircleByContComRespDto_1!= null){
          for (TargetContentDto targetContentDto : batchQueryVirtualCircleByContComRespDto_1.getTargetContentList()) {
                if (targetContentDto.getEntityId().equals(omsTspeCycleStageData.getBelongToContentId())) {
                 if(batchQueryVirtualCircleByContComRespDto_1!=null){
      retElm.setDeptId(targetContentDto.getDeptId());//SimpleFieldAssign//sourceId:410172_2
retElm.setPersonLiableInductionRecordId(targetContentDto.getPersonLiableInductionRecordId());//SimpleFieldAssign//sourceId:410173_2
retElm.setDirectorInductionRecordId(targetContentDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:410174_2
    }
                }
            }
          }

          }
        }//sourceId:1981348_1




return retData;
  }
/**
   * D3查询未完成汇报任务列表[10144]
   * gen by moon at 8/21/2024, 11:35:56 PM
   */
  @Trace(operationName = "D3查询未完成汇报任务列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryIncompleteReportTaskListRespDto queryIncompleteReportTaskList(QueryIncompleteReportTaskListReqDto reqDto){


      QueryIncompleteReportTaskListComRespDto queryIncompleteReportTaskListComRespDto_1 =null;
BatchQueryDeptComRespDto batchQueryDeptComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_3 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1982299_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1982300_1
receptionServiceReq.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1982301_1
receptionServiceReq.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1982302_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1982303_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);




//步骤1: D3查询未完成汇报任务列表(公共) - queryIncompleteReportTaskListCom
     QueryIncompleteReportTaskListComRespDto queryIncompleteReportTaskListComRespDto = null;
    QueryIncompleteReportTaskListComReqDto queryIncompleteReportTaskListComReqDto=new QueryIncompleteReportTaskListComReqDto();
  if(reqDto!=null){
      queryIncompleteReportTaskListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1981862_1
queryIncompleteReportTaskListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1981858_1
queryIncompleteReportTaskListComReqDto.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1981859_1
queryIncompleteReportTaskListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1981860_1
queryIncompleteReportTaskListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1981861_1
    }

    /*D3查询未完成汇报任务列表(公共)[10140]   */

      queryIncompleteReportTaskListComRespDto = queryIncompleteReportTaskListCom(queryIncompleteReportTaskListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryIncompleteReportTaskListComRespDto_1 = queryIncompleteReportTaskListComRespDto;

//步骤2: D1批量查询部门(公共) - batchQueryDeptCom
     BatchQueryDeptComRespDto batchQueryDeptComRespDto = null;
    if(queryIncompleteReportTaskListComRespDto !=null){
          BatchQueryDeptComReqDto batchQueryDeptComReqDto=new BatchQueryDeptComReqDto();
  if(queryIncompleteReportTaskListComRespDto!= null&&  queryIncompleteReportTaskListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryIncompleteReportTaskListComRespDto.getTaskDataList())){
      batchQueryDeptComReqDto.setDeptList(queryIncompleteReportTaskListComRespDto.getTaskDataList().stream().map(item->item.getDeptId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981864_1
    }

    /*D1批量查询牵头部门简称(公共)[7511]   */

      batchQueryDeptComRespDto = fwBaseOrgClient.batchQueryDeptCom(batchQueryDeptComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryDeptComRespDto_1 = batchQueryDeptComRespDto;
           }

//步骤3: D1-3批量查询就职记录列表（公共） - batchQueryInductionRecordListCom
     BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
    if(queryIncompleteReportTaskListComRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto=new BatchQueryInductionRecordListComReqDto();
  if(queryIncompleteReportTaskListComRespDto!= null&&  queryIncompleteReportTaskListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryIncompleteReportTaskListComRespDto.getTaskDataList())){
      batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(queryIncompleteReportTaskListComRespDto.getTaskDataList().stream().map(item->String.valueOf(item.getPersonLiableInductionRecordId()))
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981867_1
    }

    /*D1-3批量查责任人就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_1 = batchQueryInductionRecordListComRespDto;
           }

//步骤4: D1-3批量查询就职记录列表（公共） - batchQueryInductionRecordListCom
     BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_2 = null;
    if(queryIncompleteReportTaskListComRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto_1=new BatchQueryInductionRecordListComReqDto();
  if(queryIncompleteReportTaskListComRespDto!= null&&  queryIncompleteReportTaskListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryIncompleteReportTaskListComRespDto.getTaskDataList())){
      batchQueryInductionRecordListComReqDto_1.setPerOrgInductionRecordList(queryIncompleteReportTaskListComRespDto.getTaskDataList().stream().map(item->String.valueOf(item.getDirectorInductionRecordId()))
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1981870_1
    }

    /*D1-3批量查询主管就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto_2 = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_3 = batchQueryInductionRecordListComRespDto_2;
           }

QueryIncompleteReportTaskListRespDto retData = new QueryIncompleteReportTaskListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryIncompleteReportTaskListComRespDto_1!= null && !CollectionUtil.isEmpty(queryIncompleteReportTaskListComRespDto_1.getTaskDataList()) ){
          for (TaskDataDto taskDataDto : queryIncompleteReportTaskListComRespDto_1.getTaskDataList()) {
              TaskDataDto retElm = new TaskDataDto();
             if(queryIncompleteReportTaskListComRespDto_1!=null){
      retElm.setTaskId(taskDataDto.getTaskId());//SimpleFieldAssign//sourceId:410478_2
retElm.setTaskName(taskDataDto.getTaskName());//SimpleFieldAssign//sourceId:410479_2
retElm.setStateCode(taskDataDto.getStateCode());//SimpleFieldAssign//sourceId:410480_2
retElm.setCycleStandardName(taskDataDto.getCycleStandardName());//SimpleFieldAssign//sourceId:410481_2
retElm.setBelongToContentId(taskDataDto.getBelongToContentId());//SimpleFieldAssign//sourceId:410482_2
retElm.setDeptId(taskDataDto.getDeptId());//SimpleFieldAssign//sourceId:410483_2
retElm.setPersonLiableInductionRecordId(taskDataDto.getPersonLiableInductionRecordId());//SimpleFieldAssign//sourceId:410484_2
retElm.setDirectorInductionRecordId(taskDataDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:410485_2
    }
              retData.getTaskDataList().add(retElm);
               if(batchQueryDeptComRespDto_1!= null){
          for (DeptDto deptDto : batchQueryDeptComRespDto_1.getDeptList()) {
                if (deptDto.getDeptId().equals(taskDataDto.getDeptId())) {
                 if(batchQueryDeptComRespDto_1!=null){
      retElm.setDeptShortName(deptDto.getDeptShortName());//SimpleFieldAssign//sourceId:410486_2
    }
                }
            }
          }

 if(batchQueryInductionRecordListComRespDto_1!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_1.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(taskDataDto.getPersonLiableInductionRecordId())) {
                 if(batchQueryInductionRecordListComRespDto_1!=null){
      retElm.setPersonLiableUserFace(perOrgInductionRecordDto.getUserFace());//SimpleFieldAssign//sourceId:410487_2
retElm.setPersonLiableIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:410488_2
retElm.setPersonLiableNickName(perOrgInductionRecordDto.getNickName());//SimpleFieldAssign//sourceId:410489_2
    }
                }
            }
          }

 if(batchQueryInductionRecordListComRespDto_3!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_3.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(taskDataDto.getDirectorInductionRecordId())) {
                 if(batchQueryInductionRecordListComRespDto_3!=null){
      retElm.setDirectorUserFace(perOrgInductionRecordDto.getUserFace());//SimpleFieldAssign//sourceId:410492_2
retElm.setDirectorIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:410490_2
retElm.setDirectorNickName(perOrgInductionRecordDto.getNickName());//SimpleFieldAssign//sourceId:410491_2
    }
                }
            }
          }

          }
        }//sourceId:1982311_1




return retData;
  }
/**
   * D3查询目标内容最新数据点列表(公共)[10145]
   * gen by moon at 10/15/2024, 8:41:42 PM
   */
  @Trace(operationName = "D3查询目标内容最新数据点列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContNewestDatasListComRespDto queryTargetContNewestDatasListCom(QueryTargetContNewestDatasListComReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle_1 =new ArrayList<>();
BatchQueryMultipleDataByEntityIdComRespDto batchQueryMultipleDataByEntityIdComRespDto_1 =null;
//virtualUsage D3查询小圈子成员列表(公共)  72414
      QueryVirtualOrgMemListComRespDto queryVirtualOrgMemListComRespDto = null;
    QueryVirtualOrgMemListComReqDto queryVirtualOrgMemListComReqDto=new QueryVirtualOrgMemListComReqDto();
  queryVirtualOrgMemListComReqDto.setIsPersonCharge("TRUE");//sourceId:1983042_1_72414
queryVirtualOrgMemListComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1983041_1_72414
queryVirtualOrgMemListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1983043_1_72414
if(reqDto!=null){
      queryVirtualOrgMemListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1983037_1_72414
queryVirtualOrgMemListComReqDto.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1983038_1_72414
queryVirtualOrgMemListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1983039_1_72414
queryVirtualOrgMemListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1983040_1_72414
    }

    /*D3查询小圈子成员列表(公共)[8698]   */
    Assert.isNull(queryVirtualOrgMemListComReqDto.getIsPersonCharge(),"D3查询目标内容最新数据点列表(公共)-D3查询小圈子成员列表(公共)-是否负责人不能为空",false);
Assert.isNull(queryVirtualOrgMemListComReqDto.getSubjectLifeCycle(),"D3查询目标内容最新数据点列表(公共)-D3查询小圈子成员列表(公共)-主体生命周期不能为空",false);
      queryVirtualOrgMemListComRespDto = virtualOrgService.queryVirtualOrgMemListCom(queryVirtualOrgMemListComReqDto)/*vcase invoke isSameApp*/;


      Page<?> page = null;
if((queryVirtualOrgMemListComRespDto!= null&&  queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList() !=null && queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList().size()>0)) {
        //if(D3查询小圈子成员列表(公共).虚拟组织成员列表数据集条数 大于 0)  72415

    page = CommonFunctionHelper.startPage(reqDto.getPageNum(),reqDto.getPageSize());
List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(queryVirtualOrgMemListComRespDto !=null){
          BatchQueryTargetCycleByTargetContReq batchQueryTargetCycleByTargetContReq=new BatchQueryTargetCycleByTargetContReq();
  batchQueryTargetCycleByTargetContReq.setIsSubCycle("TRUE");//sourceId:1983088_1_72416
batchQueryTargetCycleByTargetContReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1983090_1_72416
if(queryVirtualOrgMemListComRespDto!= null&&  queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList())){
      batchQueryTargetCycleByTargetContReq.setEvaObjTargetCycleList(queryVirtualOrgMemListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983081_1_72416
    }
if(reqDto!=null){
      batchQueryTargetCycleByTargetContReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1983082_1_72416
batchQueryTargetCycleByTargetContReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1983083_1_72416
batchQueryTargetCycleByTargetContReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1983089_1_72416
batchQueryTargetCycleByTargetContReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983091_1_72416
    }

    /*3-3-09批量查询目标周期By目标内容[10155]   */
    Assert.isNull(batchQueryTargetCycleByTargetContReq.getEvaObjEntityId(),"D3查询目标内容最新数据点列表(公共)-3-3-09批量查询目标周期By目标内容-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByTargetContReq.getEvaObjTypeCode(),"D3查询目标内容最新数据点列表(公共)-3-3-09批量查询目标周期By目标内容-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetCycleByTargetContReq.getIsSubCycle(),"D3查询目标内容最新数据点列表(公共)-3-3-09批量查询目标周期By目标内容-是否子周期不能为空",false);
Assert.isNull(batchQueryTargetCycleByTargetContReq.getSpaceId(),"D3查询目标内容最新数据点列表(公共)-3-3-09批量查询目标周期By目标内容-创建于空间ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByTargetContReq.getSubjectLifeCycle(),"D3查询目标内容最新数据点列表(公共)-3-3-09批量查询目标周期By目标内容-主体生命周期不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryTargetCycleByTargetCont(batchQueryTargetCycleByTargetContReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
           }
List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryTargetBelongCycleByEntityIdReq batchQueryTargetBelongCycleByEntityIdReq=new BatchQueryTargetBelongCycleByEntityIdReq();
  batchQueryTargetBelongCycleByEntityIdReq.setIsWorkCycleData("TRUE");//sourceId:1998710_1_72820
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryTargetBelongCycleByEntityIdReq.setTargetBelongCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1998707_1_72820
    }
if(reqDto!=null){
      batchQueryTargetBelongCycleByEntityIdReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1998708_1_72820
batchQueryTargetBelongCycleByEntityIdReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1998709_1_72820
batchQueryTargetBelongCycleByEntityIdReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1998711_1_72820
batchQueryTargetBelongCycleByEntityIdReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1998712_1_72820
    }

    /*3-3-09-07批量查询目标内容目标值等[10216]   */
    Assert.isNull(batchQueryTargetBelongCycleByEntityIdReq.getEvaObjEntityId(),"D3查询目标内容最新数据点列表(公共)-3-3-09-07批量查询目标内容目标值等-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByEntityIdReq.getEvaObjTypeCode(),"D3查询目标内容最新数据点列表(公共)-3-3-09-07批量查询目标内容目标值等-主树被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByEntityIdReq.getIsWorkCycleData(),"D3查询目标内容最新数据点列表(公共)-3-3-09-07批量查询目标内容目标值等-是否工作周期数据不能为空",false);
Assert.isNull(batchQueryTargetBelongCycleByEntityIdReq.getSpaceId(),"D3查询目标内容最新数据点列表(公共)-3-3-09-07批量查询目标内容目标值等-创建于空间ID不能为空",false);
      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.batchQueryTargetBelongCycleByEntityId(batchQueryTargetBelongCycleByEntityIdReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetAttributionCycle_1 = listOmsTargetAttributionCycle;
           }
BatchQueryMultipleDataByEntityIdComRespDto batchQueryMultipleDataByEntityIdComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryMultipleDataByEntityIdComReqDto batchQueryMultipleDataByEntityIdComReqDto=new BatchQueryMultipleDataByEntityIdComReqDto();
batchQueryMultipleDataByEntityIdComReqDto.setIsWorkCycleData("TRUE");//sourceId:1983415_1_72427
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryMultipleDataByEntityIdComReqDto.setStandardDataList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983418_1_72427
    }
if(reqDto!=null){
      batchQueryMultipleDataByEntityIdComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1983414_1_72427
      batchQueryMultipleDataByEntityIdComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1983416_1_72427
batchQueryMultipleDataByEntityIdComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983417_1_72427
    }

    /*D4批量查询多数据点By归属内容表主键(公共)[10156]   */
Assert.isNull(batchQueryMultipleDataByEntityIdComReqDto.getIsWorkCycleData(),"D3查询目标内容最新数据点列表(公共)-D4批量查询多数据点By归属内容表主键(公共)-是否工作周期数据不能为空",false);
Assert.isNull(batchQueryMultipleDataByEntityIdComReqDto.getSpaceId(),"D3查询目标内容最新数据点列表(公共)-D4批量查询多数据点By归属内容表主键(公共)-创建于空间ID不能为空",false);
      batchQueryMultipleDataByEntityIdComRespDto = fwCalcDashboradStandardDataClient.batchQueryMultipleDataByEntityIdCom(batchQueryMultipleDataByEntityIdComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryMultipleDataByEntityIdComRespDto_1 = batchQueryMultipleDataByEntityIdComRespDto;
           }
      }
QueryTargetContNewestDatasListComRespDto retData = new QueryTargetContNewestDatasListComRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsEvaluationObjectTargetCycle_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1) && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1) ){
          for (OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle : listOmsEvaluationObjectTargetCycle_1) {
              EvaObjTargetCycleDto retElm = new EvaObjTargetCycleDto();
             retElm.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:411371_2
retElm.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:411373_2
retElm.setCyclelAlias(omsEvaluationObjectTargetCycle.getCyclelAlias());//SimpleFieldAssign//sourceId:411372_2
retElm.setTargetContentNumber(omsEvaluationObjectTargetCycle.getTargetContentNumber());//SimpleFieldAssign//sourceId:411376_2
retElm.setTargetTreeOrderNumber(omsEvaluationObjectTargetCycle.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:411377_2
              retData.getEvaObjTargetCycleList().add(retElm);
               if(listOmsTargetAttributionCycle_1!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle_1)){
          for (OmsTargetAttributionCycle omsTargetAttributionCycle : listOmsTargetAttributionCycle_1) {
                if (omsTargetAttributionCycle.getEntityId().equals(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId())) {
retElm.setOneLevelCategoryId(omsTargetAttributionCycle.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:416841_2
retElm.setCorrelationLastTargetCatId(omsTargetAttributionCycle.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:416842_2
retElm.setDashboradPrimaryDeptId(omsTargetAttributionCycle.getDashboradPrimaryDeptId());//SimpleFieldAssign//sourceId:416843_2
retElm.setDashboradOriginalRoleMemberId(omsTargetAttributionCycle.getDashboradOriginalRoleMemberId());//SimpleFieldAssign//sourceId:416844_2
retElm.setDashboradDirectorOriginalRoleMemberId(omsTargetAttributionCycle.getDashboradDirectorOriginalRoleMemberId());//SimpleFieldAssign//sourceId:416845_2
retElm.setEvaTargetValue(omsTargetAttributionCycle.getEvaTargetValue());//SimpleFieldAssign//sourceId:416840_2
                }
            }
          }

 if(batchQueryMultipleDataByEntityIdComRespDto_1!= null){
          for (StandardDataDto standardDataDto : batchQueryMultipleDataByEntityIdComRespDto_1.getStandardDataList()) {
                if (standardDataDto.getEntityId().equals(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId())) {
                 if(batchQueryMultipleDataByEntityIdComRespDto_1!=null){
      retElm.setProgressValue(standardDataDto.getProgressValue());//SimpleFieldAssign//sourceId:411384_2
retElm.setProgressChangeFromLastValue(standardDataDto.getProgressChangeFromLastValue());//SimpleFieldAssign//sourceId:411385_2
retElm.setProgressChangeFromLastRatio(standardDataDto.getProgressChangeFromLastRatio());//SimpleFieldAssign//sourceId:411386_2
retElm.setProgressUnit(standardDataDto.getProgressUnit());//SimpleFieldAssign//sourceId:411387_2
retElm.setActualValue(standardDataDto.getActualValue());//SimpleFieldAssign//sourceId:411388_2
retElm.setActualChangeFromLastValue(standardDataDto.getActualChangeFromLastValue());//SimpleFieldAssign//sourceId:411389_2
retElm.setActualChangeFromLastRatio(standardDataDto.getActualChangeFromLastRatio());//SimpleFieldAssign//sourceId:411390_2
retElm.setActualUnit(standardDataDto.getActualUnit());//SimpleFieldAssign//sourceId:411391_2
retElm.setReachValue(standardDataDto.getReachValue());//SimpleFieldAssign//sourceId:411392_2
retElm.setReachChangeFromLastValue(standardDataDto.getReachChangeFromLastValue());//SimpleFieldAssign//sourceId:411393_2
retElm.setReachChangeFromLastRatio(standardDataDto.getReachChangeFromLastRatio());//SimpleFieldAssign//sourceId:411394_2
retElm.setReachUnit(standardDataDto.getReachUnit());//SimpleFieldAssign//sourceId:411395_2
retElm.setReportScore(standardDataDto.getReportScore()!=null? Double.valueOf(standardDataDto.getReportScore()):null);//SimpleFieldAssign//sourceId:411396_2
retElm.setReportScoreChangeFromLastValue(standardDataDto.getReportScoreChangeFromLastValue());//SimpleFieldAssign//sourceId:411397_2
retElm.setReportScoreChangeFromLastRatio(standardDataDto.getReportScoreChangeFromLastRatio());//SimpleFieldAssign//sourceId:411398_2
retElm.setReportScoreUnit(standardDataDto.getReportScoreUnit());//SimpleFieldAssign//sourceId:411399_2
    }
                }
            }
          }

          }
        }//sourceId:1983420_1

// TODO: 2023/1/13 手写代码，不要去掉
      if(page!=null){
          retData.setPageNum(page.getPageNum());
          retData.setPageSize(page.getPageSize());
          retData.setTotalNum(page.getTotal());
      }


return retData;
  }
/**
   * D3查询目标内容最新数据点列表[10157]
   * gen by moon at 9/12/2024, 3:18:44 PM
   */
  @Trace(operationName = "D3查询目标内容最新数据点列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContNewestDatasListRespDto queryTargetContNewestDatasList(QueryTargetContNewestDatasListReqDto reqDto){


      QueryTargetContNewestDatasListComRespDto queryTargetContNewestDatasListComRespDto_1 =null;
BatchQueryDeptComBorderRespDto batchQueryDeptComBorderRespDto_1 =null;
BatchQueryTargetCatComRespDto batchQueryTargetCatComRespDto_1 =null;
BatchQueryTargetCatComRespDto batchQueryTargetCatComRespDto_3 =null;
BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto_1 =null;
BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto_3 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1983862_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1983863_1
receptionServiceReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1983905_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1983865_1
receptionServiceReq.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1983864_1
receptionServiceReq.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1983866_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1983867_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983868_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3查询目标内容最新数据点列表-M3接收入参字段-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3查询目标内容最新数据点列表-M3接收入参字段-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询目标内容最新数据点列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



    
//步骤1: D3查询目标内容最新数据点列表(公共) - queryTargetContNewestDatasListCom
     QueryTargetContNewestDatasListComRespDto queryTargetContNewestDatasListComRespDto = null;
    QueryTargetContNewestDatasListComReqDto queryTargetContNewestDatasListComReqDto=new QueryTargetContNewestDatasListComReqDto();
      // TODO: 2024/9/13    
    queryTargetContNewestDatasListComReqDto.setPageNum(reqDto.getPageNum());
      queryTargetContNewestDatasListComReqDto.setPageSize(reqDto.getPageSize());
    if(reqDto!=null){
      queryTargetContNewestDatasListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1983426_1
queryTargetContNewestDatasListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1983427_1
queryTargetContNewestDatasListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1983425_1
queryTargetContNewestDatasListComReqDto.setIsLast(reqDto.getIsLast());//SimpleFieldAssign//sourceId:1983421_1
queryTargetContNewestDatasListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1983422_1
queryTargetContNewestDatasListComReqDto.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1983903_1
queryTargetContNewestDatasListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1983423_1
queryTargetContNewestDatasListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983424_1
    }

    /*D3查询目标内容最新数据点列表(公共)[10145]   */
    Assert.isNull(queryTargetContNewestDatasListComReqDto.getEvaObjEntityId(),"D3查询目标内容最新数据点列表-D3查询目标内容最新数据点列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetContNewestDatasListComReqDto.getEvaObjTypeCode(),"D3查询目标内容最新数据点列表-D3查询目标内容最新数据点列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetContNewestDatasListComReqDto.getSpaceId(),"D3查询目标内容最新数据点列表-D3查询目标内容最新数据点列表(公共)-创建于空间ID不能为空",false);
      queryTargetContNewestDatasListComRespDto = queryTargetContNewestDatasListCom(queryTargetContNewestDatasListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryTargetContNewestDatasListComRespDto_1 = queryTargetContNewestDatasListComRespDto;

//步骤2: D1-3批量查部门(公共)(边界) - batchQueryDeptComBorder
     BatchQueryDeptComBorderRespDto batchQueryDeptComBorderRespDto = null;
    if(queryTargetContNewestDatasListComRespDto !=null){
          BatchQueryDeptComBorderReqDto batchQueryDeptComBorderReqDto=new BatchQueryDeptComBorderReqDto();
  if(queryTargetContNewestDatasListComRespDto!= null&&  queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList())){
      batchQueryDeptComBorderReqDto.setDeptList(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getDashboradPrimaryDeptId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983856_1
    }

    /*D1-3批量查部门(公共)(边界)[2568]   */

      batchQueryDeptComBorderRespDto = fwBaseOrgClient.batchQueryDeptComBorder(batchQueryDeptComBorderReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryDeptComBorderRespDto_1 = batchQueryDeptComBorderRespDto;
           }

//步骤3: D3批量查询目标分类(公共) - batchQueryTargetCatCom
     BatchQueryTargetCatComRespDto batchQueryTargetCatComRespDto = null;
    if(queryTargetContNewestDatasListComRespDto !=null){
          BatchQueryTargetCatComReqDto batchQueryTargetCatComReqDto=new BatchQueryTargetCatComReqDto();
  if(queryTargetContNewestDatasListComRespDto!= null&&  queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCatComReqDto.setTargetCatList(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getOneLevelCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983858_1
    }

    /*D3批量查询一级目标分类(公共)[8827]   */

      batchQueryTargetCatComRespDto = indexSystemService.batchQueryTargetCatCom(batchQueryTargetCatComReqDto)/*vcase invoke isSameApp*/;


      batchQueryTargetCatComRespDto_1 = batchQueryTargetCatComRespDto;
           }

//步骤4: D3批量查询目标分类(公共) - batchQueryTargetCatCom
     BatchQueryTargetCatComRespDto batchQueryTargetCatComRespDto_2 = null;
    if(queryTargetContNewestDatasListComRespDto !=null){
          BatchQueryTargetCatComReqDto batchQueryTargetCatComReqDto_1=new BatchQueryTargetCatComReqDto();
  if(queryTargetContNewestDatasListComRespDto!= null&&  queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCatComReqDto_1.setTargetCatList(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getCorrelationLastTargetCatId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983860_1
    }

    /*D3批量查询末级目标分类(公共)[8827]   */

      batchQueryTargetCatComRespDto_2 = indexSystemService.batchQueryTargetCatCom(batchQueryTargetCatComReqDto_1)/*vcase invoke isSameApp*/;


      batchQueryTargetCatComRespDto_3 = batchQueryTargetCatComRespDto_2;
           }

//步骤5: D1批量查询个人资料By身份人员(公共) - batchQueryUserinfoByMemberCom
     BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto = null;
    if(queryTargetContNewestDatasListComRespDto !=null){
          BatchQueryUserinfoByMemberComReqDto batchQueryUserinfoByMemberComReqDto=new BatchQueryUserinfoByMemberComReqDto();
  if(queryTargetContNewestDatasListComRespDto!= null&&  queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList())){
      batchQueryUserinfoByMemberComReqDto.setBeginMemberList(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getDashboradOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983877_1
    }
if(reqDto!=null){
      batchQueryUserinfoByMemberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983878_1
    }

    /*D1批量查询负责人个人信息[9064]   */
    Assert.isNull(batchQueryUserinfoByMemberComReqDto.getSpaceId(),"D3查询目标内容最新数据点列表-D1批量查询负责人个人信息-创建于空间ID不能为空",false);
      batchQueryUserinfoByMemberComRespDto = fwBaseDashboardOrgClient.batchQueryUserinfoByMemberCom(batchQueryUserinfoByMemberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryUserinfoByMemberComRespDto_1 = batchQueryUserinfoByMemberComRespDto;
           }

//步骤6: D1批量查询个人资料By身份人员(公共) - batchQueryUserinfoByMemberCom
     BatchQueryUserinfoByMemberComRespDto batchQueryUserinfoByMemberComRespDto_2 = null;
    if(queryTargetContNewestDatasListComRespDto !=null){
          BatchQueryUserinfoByMemberComReqDto batchQueryUserinfoByMemberComReqDto_1=new BatchQueryUserinfoByMemberComReqDto();
  if(queryTargetContNewestDatasListComRespDto!= null&&  queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList())){
      batchQueryUserinfoByMemberComReqDto_1.setBeginMemberList(queryTargetContNewestDatasListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getDashboradDirectorOriginalRoleMemberId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1983880_1
    }
if(reqDto!=null){
      batchQueryUserinfoByMemberComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1983881_1
    }

    /*D1批量查询主管个人信息[9064]   */
    Assert.isNull(batchQueryUserinfoByMemberComReqDto_1.getSpaceId(),"D3查询目标内容最新数据点列表-D1批量查询主管个人信息-创建于空间ID不能为空",false);
      batchQueryUserinfoByMemberComRespDto_2 = fwBaseDashboardOrgClient.batchQueryUserinfoByMemberCom(batchQueryUserinfoByMemberComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryUserinfoByMemberComRespDto_3 = batchQueryUserinfoByMemberComRespDto_2;
           }

QueryTargetContNewestDatasListRespDto retData = new QueryTargetContNewestDatasListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryTargetContNewestDatasListComRespDto_1!= null && !CollectionUtil.isEmpty(queryTargetContNewestDatasListComRespDto_1.getEvaObjTargetCycleList()) ){
          for (EvaObjTargetCycleDto evaObjTargetCycleDto : queryTargetContNewestDatasListComRespDto_1.getEvaObjTargetCycleList()) {
              EvaObjTargetCycleDto retElm = new EvaObjTargetCycleDto();
             if(queryTargetContNewestDatasListComRespDto_1!=null){
      retElm.setEvaObjTargetCycleId(evaObjTargetCycleDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:411685_2
retElm.setTargetCycleContentId(evaObjTargetCycleDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:411686_2
retElm.setCyclelAlias(evaObjTargetCycleDto.getCyclelAlias());//SimpleFieldAssign//sourceId:411687_2
retElm.setTargetContentNumber(evaObjTargetCycleDto.getTargetContentNumber());//SimpleFieldAssign//sourceId:411688_2
retElm.setOneLevelCategoryId(evaObjTargetCycleDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:416854_2
retElm.setCorrelationLastTargetCatId(evaObjTargetCycleDto.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:416855_2
retElm.setEvaTargetValue(evaObjTargetCycleDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:416852_2
retElm.setProgressValue(evaObjTargetCycleDto.getProgressValue());//SimpleFieldAssign//sourceId:423607_2
retElm.setProgressChangeFromLastValue(evaObjTargetCycleDto.getProgressChangeFromLastValue());//SimpleFieldAssign//sourceId:423608_2
retElm.setProgressChangeFromLastRatio(evaObjTargetCycleDto.getProgressChangeFromLastRatio());//SimpleFieldAssign//sourceId:423609_2
retElm.setProgressUnit(evaObjTargetCycleDto.getProgressUnit());//SimpleFieldAssign//sourceId:423610_2
retElm.setActualValue(evaObjTargetCycleDto.getActualValue());//SimpleFieldAssign//sourceId:423611_2
retElm.setActualChangeFromLastValue(evaObjTargetCycleDto.getActualChangeFromLastValue());//SimpleFieldAssign//sourceId:423612_2
retElm.setActualChangeFromLastRatio(evaObjTargetCycleDto.getActualChangeFromLastRatio());//SimpleFieldAssign//sourceId:423613_2
retElm.setActualUnit(evaObjTargetCycleDto.getActualUnit());//SimpleFieldAssign//sourceId:423614_2
retElm.setReachValue(evaObjTargetCycleDto.getReachValue());//SimpleFieldAssign//sourceId:423615_2
retElm.setReachChangeFromLastValue(evaObjTargetCycleDto.getReachChangeFromLastValue());//SimpleFieldAssign//sourceId:423616_2
retElm.setReachChangeFromLastRatio(evaObjTargetCycleDto.getReachChangeFromLastRatio());//SimpleFieldAssign//sourceId:423617_2
retElm.setReachUnit(evaObjTargetCycleDto.getReachUnit());//SimpleFieldAssign//sourceId:423618_2
retElm.setReportScore(evaObjTargetCycleDto.getReportScore());//SimpleFieldAssign//sourceId:423619_2
retElm.setReportScoreChangeFromLastValue(evaObjTargetCycleDto.getReportScoreChangeFromLastValue());//SimpleFieldAssign//sourceId:423620_2
retElm.setReportScoreChangeFromLastRatio(evaObjTargetCycleDto.getReportScoreChangeFromLastRatio());//SimpleFieldAssign//sourceId:423621_2
retElm.setReportScoreUnit(evaObjTargetCycleDto.getReportScoreUnit());//SimpleFieldAssign//sourceId:423622_2
retElm.setTargetTreeOrderNumber(evaObjTargetCycleDto.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:411711_2
    }
              retData.getEvaObjTargetCycleList().add(retElm);
               if(batchQueryTargetCatComRespDto_1!= null){
          for (TargetCatDto targetCatDto : batchQueryTargetCatComRespDto_1.getTargetCatList()) {
                if (targetCatDto.getTargetCategoryId().equals(evaObjTargetCycleDto.getOneLevelCategoryId())) {
                 if(batchQueryTargetCatComRespDto_1!=null){
      retElm.setOneLevelTargetCategoryName(targetCatDto.getTargetCategoryName());//SimpleFieldAssign//sourceId:411714_2
    }
                }
            }
          }

 if(batchQueryTargetCatComRespDto_3!= null){
          for (TargetCatDto targetCatDto : batchQueryTargetCatComRespDto_3.getTargetCatList()) {
                if (targetCatDto.getTargetCategoryId().equals(evaObjTargetCycleDto.getCorrelationLastTargetCatId())) {
                 if(batchQueryTargetCatComRespDto_3!=null){
      retElm.setCorrelationLastTargetCategoryName(targetCatDto.getTargetCategoryName());//SimpleFieldAssign//sourceId:411715_2
    }
                }
            }
          }

 if(batchQueryDeptComBorderRespDto_1!= null){
          for (DeptDto deptDto : batchQueryDeptComBorderRespDto_1.getDeptList()) {
                if (deptDto.getDeptId().equals(evaObjTargetCycleDto.getDashboradPrimaryDeptId())) {
                 if(batchQueryDeptComBorderRespDto_1!=null){
      retElm.setDeptId(deptDto.getDeptId());//SimpleFieldAssign//sourceId:411712_2
retElm.setDeptShortName(deptDto.getDeptShortName());//SimpleFieldAssign//sourceId:411713_2
    }
                }
            }
          }

 if(batchQueryUserinfoByMemberComRespDto_1!= null){
          for (BeginMemberDto beginMemberDto : batchQueryUserinfoByMemberComRespDto_1.getBeginMemberList()) {
                if (beginMemberDto.getOriginalRoleMemberId().equals(evaObjTargetCycleDto.getDashboradOriginalRoleMemberId())) {
                 if(batchQueryUserinfoByMemberComRespDto_1!=null){
      retElm.setPersonLiableUserFace(beginMemberDto.getUserFace());//SimpleFieldAssign//sourceId:411730_2
retElm.setPersonLiableIdCardName(beginMemberDto.getIdCardName());//SimpleFieldAssign//sourceId:411728_2
retElm.setPersonLiableNickName(beginMemberDto.getNickName());//SimpleFieldAssign//sourceId:411729_2
    }
                }
            }
          }

 if(batchQueryUserinfoByMemberComRespDto_3!= null){
          for (BeginMemberDto beginMemberDto : batchQueryUserinfoByMemberComRespDto_3.getBeginMemberList()) {
                if (beginMemberDto.getOriginalRoleMemberId().equals(evaObjTargetCycleDto.getDashboradDirectorOriginalRoleMemberId())) {
                 if(batchQueryUserinfoByMemberComRespDto_3!=null){
      retElm.setDirectorUserFace(beginMemberDto.getUserFace());//SimpleFieldAssign//sourceId:411733_2
retElm.setDirectorIdCardName(beginMemberDto.getIdCardName());//SimpleFieldAssign//sourceId:411731_2
retElm.setDirectorNickName(beginMemberDto.getNickName());//SimpleFieldAssign//sourceId:411732_2
    }
                }
            }
          }

          }
        }//sourceId:1983876_1

      // TODO: 2024/9/13
      if(queryTargetContNewestDatasListComRespDto_1!=null){
          retData.setTotalNum(queryTargetContNewestDatasListComRespDto_1.getTotalNum());
          retData.setPageNum(queryTargetContNewestDatasListComRespDto_1.getPageNum());
          retData.setPageSize(queryTargetContNewestDatasListComRespDto_1.getPageSize());
      }



return retData;
  }
/**
   * D3执行分析是否实际验收周期(公共)[10160]
   * gen by moon at 8/23/2024, 7:11:22 PM
   */
  @Trace(operationName = "D3执行分析是否实际验收周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyzeIsActualAcceptanceCycleComRespDto implementAnalyzeIsActualAcceptanceCycleCom(ImplementAnalyzeIsActualAcceptanceCycleComReqDto reqDto){


      ImplementEightReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage 3-2-02查评价模板详情  72462
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1984977_1_72462
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1984976_1_72462
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3执行分析是否实际验收周期(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3执行分析是否实际验收周期(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2-3查配置项匹配答案详情(公共)（跨服务）  72461
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("NOT_COMPLETED_REPORT_TASK_CAN_BE_ACCEPTED_IN_ADVANCE");//CUSTOM_CONVENTION//sourceId:1984935_1_72461
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1984936_1_72461
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1984934_1_72461
    }

    /*D2-3查配置项匹配答案详情(公共)（跨服务）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行分析是否实际验收周期(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行分析是否实际验收周期(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行分析是否实际验收周期(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto== null||  queryConfItemMatchAnswerDetailComRespDto.getEndValue() ==null,"找不到数据，系统异常",false);


           }
if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE"))) {
        //if(D2-3查目标未完成是否可以提前验收.答案值 等于 是)  72463

//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setIsActualReceptionCycle(reqDto.getIsActualReceptionCycle());//SimpleFieldAssign//sourceId:1984904_1_72474
    }

    /*M3-接收出参字段：是否实际验收周期[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getIsActualReceptionCycle(),"D3执行分析是否实际验收周期(公共)-M3-接收出参字段：是否实际验收周期-是否实际验收周期不能为空",false);
      receptionServiceRes = nbEvaCalc.implementEightReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE"))){
       //elseif(D2-3查目标未完成是否可以提前验收.答案值 等于 否)  72464

JudgeIsTheActualAcceptanceCycleComRespDto judgeIsTheActualAcceptanceCycleComRespDto = null;
    JudgeIsTheActualAcceptanceCycleComReqDto judgeIsTheActualAcceptanceCycleComReqDto=new JudgeIsTheActualAcceptanceCycleComReqDto();
  if(reqDto!=null){
      judgeIsTheActualAcceptanceCycleComReqDto.setIsActualReceptionCycle(reqDto.getIsActualReceptionCycle());//SimpleFieldAssign//sourceId:1984909_1_72465
judgeIsTheActualAcceptanceCycleComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:1984910_1_72465
judgeIsTheActualAcceptanceCycleComReqDto.setQuantityObjectiveNoValue(reqDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:1984911_1_72465
judgeIsTheActualAcceptanceCycleComReqDto.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:1984906_1_72465
judgeIsTheActualAcceptanceCycleComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1984907_1_72465
judgeIsTheActualAcceptanceCycleComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1984908_1_72465
    }

    /*D3判断是否实际验收周期(公共)[9471]   */
    Assert.isNull(judgeIsTheActualAcceptanceCycleComReqDto.getIsActualReceptionCycle(),"D3执行分析是否实际验收周期(公共)-D3判断是否实际验收周期(公共)-是否实际验收周期不能为空",false);
      judgeIsTheActualAcceptanceCycleComRespDto = targetCalcService.judgeIsTheActualAcceptanceCycleCom(judgeIsTheActualAcceptanceCycleComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    if(judgeIsTheActualAcceptanceCycleComRespDto !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
  if(judgeIsTheActualAcceptanceCycleComRespDto!=null){
      receptionServiceReq_1.setIsActualReceptionCycle(judgeIsTheActualAcceptanceCycleComRespDto.getIsActualReceptionCycle());//SimpleFieldAssign//sourceId:1984904_1_72473
    }

    /*M3-接收出参字段：是否实际验收周期[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsActualReceptionCycle(),"D3执行分析是否实际验收周期(公共)-M3-接收出参字段：是否实际验收周期-是否实际验收周期不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementEightReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
ImplementAnalyzeIsActualAcceptanceCycleComRespDto retData = new ImplementAnalyzeIsActualAcceptanceCycleComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsActualReceptionCycle(receptionServiceRes_1.getIsActualReceptionCycle());//SimpleFieldAssign//sourceId:1984998_1
    }




return retData;
  }
/**
   * D3查询目标周期祖先列表列表(公共)[10213]
   * gen by moon at 9/4/2024, 2:34:03 AM
   */
  @Trace(operationName = "D3查询目标周期祖先列表列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTagetCycleAncestorListComRespDto queryTagetCycleAncestorListCom(QueryTagetCycleAncestorListComReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1996141_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1996142_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1996143_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1996144_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1996149_1
    }

    /*M3-接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleCode(),"D3查询目标周期祖先列表列表(公共)-M3-接收入参字段-被评对象目标周期标识不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3查询目标周期祖先列表列表(公共)-M3-接收入参字段-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3查询目标周期祖先列表列表(公共)-M3-接收入参字段-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标周期祖先列表列表(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询目标周期祖先列表列表(公共)-M3-接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementEightReceivingField(receptionServiceReq);




//步骤1: D2执行找祖先标识(公共) - implementLookAncestorNodeCodeCom
     ImplementLookAncestorNodeCodeComRespDto implementLookAncestorNodeCodeComRespDto = null;
    ImplementLookAncestorNodeCodeComReqDto implementLookAncestorNodeCodeComReqDto=new ImplementLookAncestorNodeCodeComReqDto();
  if(reqDto!=null){
      implementLookAncestorNodeCodeComReqDto.setComCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1996131_1
    }

    /*D2执行找祖先标识(公共)[6307]   */
    Assert.isNull(implementLookAncestorNodeCodeComReqDto.getComCode(),"D3查询目标周期祖先列表列表(公共)-D2执行找祖先标识(公共)-通用编码标识不能为空",false);
      implementLookAncestorNodeCodeComRespDto = fwCompInterfaceModeClient.implementLookAncestorNodeCodeCom(implementLookAncestorNodeCodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: 3-3-09批量查询目标周期by内容标识 - batchQueryTargetCycleByContentCodes
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(implementLookAncestorNodeCodeComRespDto !=null){
          BatchQueryTargetCycleByContentCodesReq batchQueryTargetCycleByContentCodesReq=new BatchQueryTargetCycleByContentCodesReq();
  batchQueryTargetCycleByContentCodesReq.setIsParentCycle("TRUE");//sourceId:1996136_1
batchQueryTargetCycleByContentCodesReq.setIsArchive("FALSE");//sourceId:1996138_1
if(implementLookAncestorNodeCodeComRespDto!=null){
      batchQueryTargetCycleByContentCodesReq.setEvaObjTargetCycleList(implementLookAncestorNodeCodeComRespDto.getLookAncestorNodeList());//list-field-assign//sourceId:1996133_1
    }
if(reqDto!=null){
      batchQueryTargetCycleByContentCodesReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1996134_1
batchQueryTargetCycleByContentCodesReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1996135_1
batchQueryTargetCycleByContentCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1996137_1
batchQueryTargetCycleByContentCodesReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1996139_1
    }

    /*3-3-09批量查询目标周期by内容标识[9589]   */
    Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjEntityId(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjTypeCode(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsParentCycle(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-是否父周期不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaluationTemplateId(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsArchive(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-是否存档不能为空",false);
Assert.isNull(batchQueryTargetCycleByContentCodesReq.getSpaceId(),"D3查询目标周期祖先列表列表(公共)-3-3-09批量查询目标周期by内容标识-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryTargetCycleByContentCodes(batchQueryTargetCycleByContentCodesReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
           }

QueryTagetCycleAncestorListComRespDto retData = new QueryTagetCycleAncestorListComRespDto();
  retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1996154_1




return retData;
  }
/**
   * D3查询汇报任务周期筛选列表[10217]
   * gen by moon at 9/12/2024, 7:19:37 PM
   */
  @Trace(operationName = "D3查询汇报任务周期筛选列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryReportTaskCycleFilterListRespDto queryReportTaskCycleFilterList(QueryReportTaskCycleFilterListReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("FALSE"))) {
        //if(D3查询汇报任务周期筛选列表.是否过程周期阶段 等于 否)  72826

List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq=new QueryExecuteCycleStageTestListReq();
  queryExecuteCycleStageTestListReq.setRelateContentTypeCode("TARGET");//sourceId:1999145_1_72827
queryExecuteCycleStageTestListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1999153_1_72827
queryExecuteCycleStageTestListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1999143_1_72827
if(reqDto!=null){
      queryExecuteCycleStageTestListReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1999141_1_72827
queryExecuteCycleStageTestListReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1999158_1_72827
queryExecuteCycleStageTestListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999147_1_72827
    }

    /*3-3-07查询执行周期阶段列表[4288]   */
    Assert.isNull(queryExecuteCycleStageTestListReq.getIsProcessCycleStage(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getEvaluationTemplateId(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getRelateContentTypeCode(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getSubjectLifeCycle(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getSpaceId(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-创建于空间ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;
      }
else if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("TRUE")&&reqDto!= null&& reqDto.getCycleId() != null )){
       //elseif((D3查询汇报任务周期筛选列表.是否过程周期阶段 等于 是 and D3查询汇报任务周期筛选列表.周期ID 值不等于空 ))  72828

OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setRelateContentTypeCode("TARGET");//sourceId:1999693_1_72830
queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1999695_1_72830
queryExecuteCycleStageDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1999696_1_72830
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1999692_1_72830
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999694_1_72830
    }

    /*3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3查询汇报任务周期筛选列表-3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(),"D3查询汇报任务周期筛选列表-3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3查询汇报任务周期筛选列表-3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3查询汇报任务周期筛选列表-3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSpaceId(),"D3查询汇报任务周期筛选列表-3-3-07查询子周期执行周期阶段ID(用于查询过程执行周期阶段范围）-创建于空间ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    if(omsExecuteCycleStage !=null){
          QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq_1=new QueryExecuteCycleStageTestListReq();
  queryExecuteCycleStageTestListReq_1.setRelateContentTypeCode("TARGET");//sourceId:1999145_1_72829
queryExecuteCycleStageTestListReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1999153_1_72829
queryExecuteCycleStageTestListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1999143_1_72829
if(reqDto!=null){
      queryExecuteCycleStageTestListReq_1.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1999141_1_72829
queryExecuteCycleStageTestListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999147_1_72829
    }
if(omsExecuteCycleStage!=null){
      queryExecuteCycleStageTestListReq_1.setRelateExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1999701_1_72829
    }

    /*3-3-07查询执行周期阶段列表[4288]   */
    Assert.isNull(queryExecuteCycleStageTestListReq_1.getIsProcessCycleStage(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq_1.getEvaluationTemplateId(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq_1.getRelateContentTypeCode(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq_1.getSubjectLifeCycle(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq_1.getSpaceId(),"D3查询汇报任务周期筛选列表-3-3-07查询执行周期阶段列表-创建于空间ID不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq_1)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage_2;
           }
    }
QueryReportTaskCycleFilterListRespDto retData = new QueryReportTaskCycleFilterListRespDto();
  retData.setReportTaskCycleFilterList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ReportTaskCycleFilterDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1999166_1




return retData;
  }
/**
   * D3查询汇报任务部门下属人员小圈子列表(公共)[10219]
   * gen by moon at 9/13/2024, 12:58:36 PM
   */
  @Trace(operationName = "D3查询汇报任务部门下属人员小圈子列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryReportTaskDeptSubPersonnelSmallCoterieRemoDupListComRespDto queryReportTaskDeptSubPersonnelSmallCoterieRemoDupListCom(QueryReportTaskDeptSubPersonnelSmallCoterieRemoDupListComReqDto reqDto){


      ImplementEightReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage 3-2-02获取评价主题ID(用于查询评价主题配置参数）  72832
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999803_1_72832
    }

    /*3-2-02获取评价主题ID(用于查询评价主题配置参数）[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-3-2-02获取评价主题ID(用于查询评价主题配置参数）-评价模板ID不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2查评价主题部门汇报任务数算法模型参数（公共）  72833
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_THEME");//sourceId:1999766_1_72833
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("DEPT_REPORT_TASK_ALGORITHM_TYPE");//CUSTOM_CONVENTION//sourceId:1999767_1_72833
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1999768_1_72833
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1999765_1_72833
    }

    /*D2查评价主题部门汇报任务数算法模型参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D2查评价主题部门汇报任务数算法模型参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D2查评价主题部门汇报任务数算法模型参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D2查评价主题部门汇报任务数算法模型参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D2查评价主题部门汇报任务数算法模型参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("CURRENET_DEPT"))) {
        //if(D2查评价主题部门汇报任务数算法模型参数（公共）.答案值 等于 本级部门)  72834

QueryDeptSubPersonnelSmallCoterieRemoDupListComRespDto queryDeptSubPersonnelSmallCoterieRemoDupListComRespDto = null;
    QueryDeptSubPersonnelSmallCoterieRemoDupListComReqDto queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto=new QueryDeptSubPersonnelSmallCoterieRemoDupListComReqDto();
  if(reqDto!=null){
      queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1999739_1_72836
queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999740_1_72836
queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1999741_1_72836
    }

    /*D3查询部门下人员小圈子列表(公共)[8921]   */
    Assert.isNull(queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.getDeptId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下人员小圈子列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.getEvaluationTemplateId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下人员小圈子列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto.getSpaceId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下人员小圈子列表(公共)-创建于空间ID不能为空",false);
      queryDeptSubPersonnelSmallCoterieRemoDupListComRespDto = dashboardTargetContentService.queryDeptSubPersonnelSmallCoterieRemoDupListCom(queryDeptSubPersonnelSmallCoterieRemoDupListComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    if(queryDeptSubPersonnelSmallCoterieRemoDupListComRespDto !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(queryDeptSubPersonnelSmallCoterieRemoDupListComRespDto!=null){
      receptionServiceReq.setTargetContentList(queryDeptSubPersonnelSmallCoterieRemoDupListComRespDto.getTargetContentList());//list-field-assign//sourceId:2000666_1_72838
    }

    /*M3接收数据集出参[8691]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementEightReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("CURRENET_SUBORDINATE_DEPT"))){
       //elseif(D2查评价主题部门汇报任务数算法模型参数（公共）.答案值 等于 本级+下级部门)  72835

QueryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto queryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto = null;
    QueryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto=new QueryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto();
  if(reqDto!=null){
      queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1999734_1_72837
queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1999735_1_72837
queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1999736_1_72837
    }

    /*D3查询部门下所有人员小圈子列表（含非直属去重）(公共)[10078]   */
    Assert.isNull(queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.getDeptId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下所有人员小圈子列表（含非直属去重）(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.getEvaluationTemplateId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下所有人员小圈子列表（含非直属去重）(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto.getSpaceId(),"D3查询汇报任务部门下属人员小圈子列表(公共)-D3查询部门下所有人员小圈子列表（含非直属去重）(公共)-创建于空间ID不能为空",false);
      queryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto = dashboardTargetContentService.queryDeptSubAllPersonnelSmallCoterieRemoDupListCom(queryDeptSubAllPersonnelSmallCoterieRemoDupListComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    if(queryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
  if(queryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto!=null){
      receptionServiceReq_1.setTargetContentList(queryDeptSubAllPersonnelSmallCoterieRemoDupListComRespDto.getTargetContentList());//list-field-assign//sourceId:2000666_1_72839
    }

    /*M3接收数据集出参[8691]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementEightReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QueryReportTaskDeptSubPersonnelSmallCoterieRemoDupListComRespDto retData = new QueryReportTaskDeptSubPersonnelSmallCoterieRemoDupListComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTargetContentList(receptionServiceRes_1.getTargetContentList());//list-field-assign//sourceId:2000668_1
    }




return retData;
  }
/**
   * D3查询目标归属周期详情(公共)[10229]
   * gen by moon at 10/27/2024, 12:35:55 AM
   */
  @Trace(operationName = "D3查询目标归属周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetAttributionCycleDetailComRespDto queryTargetAttributionCycleDetailCom(QueryTargetAttributionCycleDetailComReqDto reqDto){


      OmsTargetAttributionCycle omsTargetAttributionCycle_1 =null;
//步骤0: 3-3-09-07查询目标归属周期详情 - queryTargetAttributionCycleDetail
     OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    QueryTargetAttributionCycleDetailReq queryTargetAttributionCycleDetailReq=new QueryTargetAttributionCycleDetailReq();
  if(reqDto!=null){
      queryTargetAttributionCycleDetailReq.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2002297_1
queryTargetAttributionCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2002298_1
queryTargetAttributionCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2002299_1
queryTargetAttributionCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2002300_1
queryTargetAttributionCycleDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2002301_1
queryTargetAttributionCycleDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2002302_1
queryTargetAttributionCycleDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:2002303_1
queryTargetAttributionCycleDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2002304_1
queryTargetAttributionCycleDetailReq.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2024382_1
queryTargetAttributionCycleDetailReq.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:2002305_1
queryTargetAttributionCycleDetailReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:2002306_1
queryTargetAttributionCycleDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2002307_1
queryTargetAttributionCycleDetailReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:2002308_1
queryTargetAttributionCycleDetailReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2002309_1
queryTargetAttributionCycleDetailReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024383_1
queryTargetAttributionCycleDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2002310_1
queryTargetAttributionCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2002311_1
queryTargetAttributionCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2002312_1
    }

    /*3-3-09-07查询目标归属周期详情[10228]   */

      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetAttributionCycleDetail(queryTargetAttributionCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetAttributionCycle_1 = omsTargetAttributionCycle;

QueryTargetAttributionCycleDetailComRespDto retData = new QueryTargetAttributionCycleDetailComRespDto();
  if(omsTargetAttributionCycle_1!=null){
      retData.setTargetAttributionCycleId(omsTargetAttributionCycle_1.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2002331_1
retData.setEntityId(omsTargetAttributionCycle_1.getEntityId());//SimpleFieldAssign//sourceId:2002332_1
retData.setEvaProgressCalcCode(omsTargetAttributionCycle_1.getEvaProgressCalcCode());//SimpleFieldAssign//sourceId:2003184_1
retData.setEvaActualCalcCode(omsTargetAttributionCycle_1.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:2003185_1
retData.setCycleId(omsTargetAttributionCycle_1.getCycleId());//SimpleFieldAssign//sourceId:2024445_1
retData.setCycleStartTime(omsTargetAttributionCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2024443_1
retData.setParentEvaObjTargetCycleId(omsTargetAttributionCycle_1.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024481_1
retData.setEvaObjTargetCycleCode(omsTargetAttributionCycle_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2024488_1
    }




return retData;
  }
/**
   * D3分析数量型指标实际值(公共)[10234]
   * gen by moon at 9/28/2024, 10:17:09 PM
   */
  @Trace(operationName = "D3分析数量型指标实际值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisQuantitativeObjectActualValueComRespDto analysisQuantitativeObjectActualValueCom(AnalysisQuantitativeObjectActualValueComReqDto reqDto){


      ImplementEightReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("NUMBER_GROWTH")||reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("NUMBER_DECLINE"))&&(reqDto!= null&&  reqDto.getIsWorkCycleData() !=null && reqDto.getIsWorkCycleData().equals("FALSE"))) {
        //if((D3分析数量型指标实际值(公共).冗余指标业务类型 等于 数量增长型 or D3分析数量型指标实际值(公共).冗余指标业务类型 等于 数量降幅型) and D3分析数量型指标实际值(公共).是否工作周期数据 等于 否)  72883

List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    QueryTargetBelongCycleByGeStartAndLtEndTimeListReq queryTargetBelongCycleByGeStartAndLtEndTimeListReq=new QueryTargetBelongCycleByGeStartAndLtEndTimeListReq();
  queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2010496_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2010497_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2010502_1_73006
if(reqDto!=null){
      queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setCycleStartTime(reqDto.getTargetCycleStartTime());//SimpleFieldAssign//sourceId:2010498_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setCycleEndTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2010499_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:2010500_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2010503_1_73006
queryTargetBelongCycleByGeStartAndLtEndTimeListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2010501_1_73006
    }

    /*3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于[10241]   */
    Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getEvaObjEntityId(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getEvaObjTypeCode(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getCycleStartTime(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getCycleEndTime(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-周期结束时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getCycleTypeCode(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-周期类型标识不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getEntityId(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getEvaluationTemplateId(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartAndLtEndTimeListReq.getSpaceId(),"D3分析数量型指标实际值(公共)-3-3-09-07查询目标归属周期列表by开始时间大于等于&结束时间小于-创建于空间ID不能为空",false);
      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByGeStartAndLtEndTimeList(queryTargetBelongCycleByGeStartAndLtEndTimeListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsTargetAttributionCycle!= null&&  listOmsTargetAttributionCycle !=null && listOmsTargetAttributionCycle.size()>0)) {
        //if(3-3-09-07通过目标归属周期表查当前周期相同周期类型之前的周期ID列表.目标归属周期列表数据集条数 大于 0)  73058

QueryTargetStandardDataCalcListComRespDto queryTargetStandardDataCalcListComRespDto = null;
    if(listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&& listOmsTargetAttributionCycle.size()>0 ){
          QueryTargetStandardDataCalcListComReqDto queryTargetStandardDataCalcListComReqDto=new QueryTargetStandardDataCalcListComReqDto();
  queryTargetStandardDataCalcListComReqDto.setIsNewData("TRUE");//sourceId:2009466_1_73061
queryTargetStandardDataCalcListComReqDto.setDataType("ACTUAL_VALUE");//sourceId:2009467_1_73061
queryTargetStandardDataCalcListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009470_1_73061
if(listOmsTargetAttributionCycle!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&&  listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)){
      queryTargetStandardDataCalcListComReqDto.setCycleList(listOmsTargetAttributionCycle.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2009464_1_73061
    }
if(reqDto!=null){
      queryTargetStandardDataCalcListComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2011099_1_73061
queryTargetStandardDataCalcListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009469_1_73061
queryTargetStandardDataCalcListComReqDto.setExtendedField3(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2009472_1_73061
    }

    /*D4查询目标标准数据列表By归属周期ID(公共)[8661]   */
    Assert.isNull(queryTargetStandardDataCalcListComReqDto.getIsNewData(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryTargetStandardDataCalcListComReqDto.getDataType(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-数据点类型不能为空",false);
Assert.isNull(queryTargetStandardDataCalcListComReqDto.getEntityId(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetStandardDataCalcListComReqDto.getThemeContentId(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-主题内容ID不能为空",false);
Assert.isNull(queryTargetStandardDataCalcListComReqDto.getSubjectLifeCycle(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-主体生命周期不能为空",false);
Assert.isNull(queryTargetStandardDataCalcListComReqDto.getExtendedField3(),"D3分析数量型指标实际值(公共)-D4查询目标标准数据列表By归属周期ID(公共)-扩展字段3不能为空",false);
      queryTargetStandardDataCalcListComRespDto = fwCalcTargetCalcClient.queryTargetStandardDataCalcListCom(queryTargetStandardDataCalcListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CalculateSumOfMultipleNumServiceComRespDto calculateSumOfMultipleNumServiceComRespDto = null;
    if(queryTargetStandardDataCalcListComRespDto !=null){
          CalculateSumOfMultipleNumServiceComReqDto calculateSumOfMultipleNumServiceComReqDto=new CalculateSumOfMultipleNumServiceComReqDto();
  calculateSumOfMultipleNumServiceComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:2009927_1_73062
calculateSumOfMultipleNumServiceComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:2009928_1_73062
if(queryTargetStandardDataCalcListComRespDto!= null&&  queryTargetStandardDataCalcListComRespDto.getStandardDataList() !=null&& !CollectionUtil.isEmpty(queryTargetStandardDataCalcListComRespDto.getStandardDataList())){
      calculateSumOfMultipleNumServiceComReqDto.setSumOfMultipleNumList(//objList-to-objLists
        queryTargetStandardDataCalcListComRespDto.getStandardDataList().stream().map(item -> {
      SumOfMultipleNumDto elm = new SumOfMultipleNumDto();
      if(item!=null){
      elm.setCommPrimaryKey(item.getEntityId());//SimpleFieldAssign//sourceId:420718_2_73062
elm.setCalcPara1(item.getDataResult());//SimpleFieldAssign//sourceId:420719_2_73062
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2009925_1_73062
    }

    /*D4-计算数据集求和服务(公共)[3375]   */
    Assert.isNull(calculateSumOfMultipleNumServiceComReqDto.getDecimalPointRules(),"D3分析数量型指标实际值(公共)-D4-计算数据集求和服务(公共)-小数点规则不能为空",false);
Assert.isNull(calculateSumOfMultipleNumServiceComReqDto.getDecimalDigitsLastRules(),"D3分析数量型指标实际值(公共)-D4-计算数据集求和服务(公共)-小数最后一位规则不能为空",false);
      calculateSumOfMultipleNumServiceComRespDto = fwCalcCalculationRulesClient.calculateSumOfMultipleNumServiceCom(calculateSumOfMultipleNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CalculateAdditionOfTwoNumServiceComRespDto calculateAdditionOfTwoNumServiceComRespDto = null;
    if(calculateSumOfMultipleNumServiceComRespDto !=null){
          CalculateAdditionOfTwoNumServiceComReqDto calculateAdditionOfTwoNumServiceComReqDto=new CalculateAdditionOfTwoNumServiceComReqDto();
  if(reqDto!=null){
      calculateAdditionOfTwoNumServiceComReqDto.setCalcPara1(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2010089_1_73063
    }
  if(calculateSumOfMultipleNumServiceComRespDto!=null){
      calculateAdditionOfTwoNumServiceComReqDto.setCalcPara2(calculateSumOfMultipleNumServiceComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:2010090_1_73063
    }

    /*D4-计算两个数相加服务(公共)[3372]   */
    Assert.isNull(calculateAdditionOfTwoNumServiceComReqDto.getCalcPara1(),"D3分析数量型指标实际值(公共)-D4-计算两个数相加服务(公共)-计算入参1不能为空",false);
Assert.isNull(calculateAdditionOfTwoNumServiceComReqDto.getCalcPara2(),"D3分析数量型指标实际值(公共)-D4-计算两个数相加服务(公共)-计算入参2不能为空",false);
      calculateAdditionOfTwoNumServiceComRespDto = fwCalcCalculationRulesClient.calculateAdditionOfTwoNumServiceCom(calculateAdditionOfTwoNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    if(calculateAdditionOfTwoNumServiceComRespDto !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(calculateAdditionOfTwoNumServiceComRespDto!=null){
      receptionServiceReq.setActualValue(calculateAdditionOfTwoNumServiceComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:2005630_1_73064
    }

    /*M3-接收出参字段：实际值[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getActualValue(),"D3分析数量型指标实际值(公共)-M3-接收出参字段：实际值-实际值（数值）不能为空",false);
      receptionServiceRes = nbEvaCalc.implementEightReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((listOmsTargetAttributionCycle!= null&&  listOmsTargetAttributionCycle !=null && listOmsTargetAttributionCycle.size()==0)){
       //elseif(3-3-09-07通过目标归属周期表查当前周期相同周期类型之前的周期ID列表.目标归属周期列表数据集条数 等于 0)  73059

    //ModelCode: receptionService
    ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
    if(reqDto!=null){
      receptionServiceReq_1.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2005630_1_73060
    }

    /*M3-接收出参字段：实际值[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getActualValue(),"D3分析数量型指标实际值(公共)-M3-接收出参字段：实际值-实际值（数值）不能为空",false);
    receptionServiceRes_2 = nbEvaCalc.implementEightReceivingField(receptionServiceReq_1);


    receptionServiceRes_1 = receptionServiceRes_2;
}

}
else if((!(reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("NUMBER_GROWTH"))&&!(reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("NUMBER_DECLINE")))||(reqDto!= null&&  reqDto.getIsWorkCycleData() !=null && reqDto.getIsWorkCycleData().equals("TRUE"))){
       //elseif((D3分析数量型指标实际值(公共).冗余指标业务类型 不等于 数量增长型 and D3分析数量型指标实际值(公共).冗余指标业务类型 不等于 数量降幅型) or D3分析数量型指标实际值(公共).是否工作周期数据 等于 是)  72884

//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_3 = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq_2=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2005630_1_72885
    }

    /*M3-接收出参字段：实际值[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getActualValue(),"D3分析数量型指标实际值(公共)-M3-接收出参字段：实际值-实际值（数值）不能为空",false);
      receptionServiceRes_3 = nbEvaCalc.implementEightReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
    }
AnalysisQuantitativeObjectActualValueComRespDto retData = new AnalysisQuantitativeObjectActualValueComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setActualValue(receptionServiceRes_1.getActualValue());//SimpleFieldAssign//sourceId:2005635_1
    }




return retData;
  }
/**
   * D3执行循环更新目标周期名称(公共)[10236]
   * gen by moon at 9/21/2024, 11:47:09 PM
   */
  @Trace(operationName = "D3执行循环更新目标周期名称(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopUpdateTargetCycleNameComRespDto implementLoopUpdateTargetCycleNameCom(ImplementLoopUpdateTargetCycleNameComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleList() !=null && reqDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3执行循环更新目标周期名称(公共).被评对象目标周期列表数据集条数 大于 0)  72903

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleList()){

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:2007521_1_72907
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:2007515_1_72907
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2007520_1_72907
    }
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleListReq.setIsParentCycle(circulationCollectionsRes.getIsParentCycle());//SimpleFieldAssign//sourceId:2007517_1_72907
queryEvaObjTargetCycleListReq.setIsMetaphase(circulationCollectionsRes.getIsMetaphase());//SimpleFieldAssign//sourceId:2007519_1_72907
queryEvaObjTargetCycleListReq.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:2007518_1_72907
    }

    /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsParentCycle(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsMetaphase(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否中期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3执行循环更新目标周期名称(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



boolean bOOLEAN ;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2=new ArrayList<>();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
      OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
      elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:420263_2_72908
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:420266_2_72908
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:420267_2_72908
if(circulationCollectionsRes!=null){
      elm.setTargetCycleName(circulationCollectionsRes.getTargetCycleName());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:420264_2_72908
elm.setCyclelAlias(circulationCollectionsRes.getCyclelAlias());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:420265_2_72908
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:2007523_1_72908
    }

    /*3-3-09-01批量修改目标周期名称与简称[2664]   */

      bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchUpdateEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementLoopUpdateTargetCycleNameComRespDto retData = new ImplementLoopUpdateTargetCycleNameComRespDto();





return retData;
  }
/**
   * D3执行回写目标归属周期是否主观评分(公共)[10237]
   * gen by moon at 9/21/2024, 11:47:26 PM
   */
  @Trace(operationName = "D3执行回写目标归属周期是否主观评分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWriteBackTargetAttributionCycleSubjectiveScoComRespDto implementWriteBackTargetAttributionCycleSubjectiveScoCom(ImplementWriteBackTargetAttributionCycleSubjectiveScoComReqDto reqDto){


      //virtualUsage 3-3-09-07查询目标归属周期详情  72911
      OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq=new QueryTargetBelongCycleDetailReq();
  if(reqDto!=null){
      queryTargetBelongCycleDetailReq.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2008264_1_72911
queryTargetBelongCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2008265_1_72911
    }

    /*3-3-09-07查询目标归属周期详情[8579]   */
    Assert.isNull(queryTargetBelongCycleDetailReq.getTargetAttributionCycleId(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07查询目标归属周期详情-目标归属周期ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq.getSpaceId(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07查询目标归属周期详情-创建于空间ID不能为空",false);
      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetAttributionCycle!= null&&  omsTargetAttributionCycle.getIsSubjectiveScoring() !=null && omsTargetAttributionCycle.getIsSubjectiveScoring().equals("TRUE"))) {
        //if(3-3-09-07查询目标归属周期详情.是否开启主观评分 等于 是)  72912

if((reqDto!= null&&  reqDto.getEnableSubjectiveRatingCycleType() !=null && reqDto.getEnableSubjectiveRatingCycleType().equals("LAST_CYCLE"))) {
        //if(D3执行回写目标归属周期是否主观评分(公共).开启主客观评分周期类型 等于 末级周期)  72918

if((omsTargetAttributionCycle!= null&&  omsTargetAttributionCycle.getIsLastCycle() !=null && omsTargetAttributionCycle.getIsLastCycle().equals("FALSE"))) {
        //if(3-3-09-07查询目标归属周期详情.是否末级周期 等于 否)  72931

boolean bOOLEAN ;
    OmsTargetAttributionCycle omsTargetAttributionCycle_2=new OmsTargetAttributionCycle();
  omsTargetAttributionCycle_2.setIsSubjectiveScoring("FALSE");//sourceId:2008713_1_72932
if(reqDto!=null){
      omsTargetAttributionCycle_2.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2008712_1_72932
    }

    /*3-3-09-07修改目标归属周期[8578]   */
    Assert.isNull(omsTargetAttributionCycle_2.getTargetAttributionCycleId(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07修改目标归属周期-目标归属周期ID不能为空",false);
Assert.isNull(omsTargetAttributionCycle_2.getIsSubjectiveScoring(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07修改目标归属周期-是否开启主观评分不能为空",false);
      bOOLEAN = mOmsTargetAttributionCycleService.updateTargetBelongCycle(omsTargetAttributionCycle_2)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
else if((reqDto!= null&&  reqDto.getEnableSubjectiveRatingCycleType() !=null && reqDto.getEnableSubjectiveRatingCycleType().equals("UNLIMITED"))){
       //elseif(D3执行回写目标归属周期是否主观评分(公共).开启主客观评分周期类型 等于 不限)  72919

if((omsTargetAttributionCycle!= null&&  omsTargetAttributionCycle.getIsWorkCycleData() !=null && omsTargetAttributionCycle.getIsWorkCycleData().equals("TRUE")&&reqDto!= null&&  reqDto.getWorkCycleIsOpenReport() !=null && reqDto.getWorkCycleIsOpenReport().equals("FALSE"))) {
        //if((3-3-09-07查询目标归属周期详情.是否工作周期数据 等于 是 and D3执行回写目标归属周期是否主观评分(公共).工作周期是否开启汇报 等于 否))  72937

boolean bOOLEAN_1 ;
    OmsTargetAttributionCycle omsTargetAttributionCycle_3=new OmsTargetAttributionCycle();
  omsTargetAttributionCycle_3.setIsSubjectiveScoring("FALSE");//sourceId:2008713_1_72938
if(reqDto!=null){
      omsTargetAttributionCycle_3.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2008712_1_72938
    }

    /*3-3-09-07修改目标归属周期[8578]   */
    Assert.isNull(omsTargetAttributionCycle_3.getTargetAttributionCycleId(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07修改目标归属周期-目标归属周期ID不能为空",false);
Assert.isNull(omsTargetAttributionCycle_3.getIsSubjectiveScoring(),"D3执行回写目标归属周期是否主观评分(公共)-3-3-09-07修改目标归属周期-是否开启主观评分不能为空",false);
      bOOLEAN_1 = mOmsTargetAttributionCycleService.updateTargetBelongCycle(omsTargetAttributionCycle_3)/*vcase invoke 本地 method 方法调用;*/;



      }
    }
      }
ImplementWriteBackTargetAttributionCycleSubjectiveScoComRespDto retData = new ImplementWriteBackTargetAttributionCycleSubjectiveScoComRespDto();





return retData;
  }
/**
   * D3转换父子中周期类型（查下级）(公共)[10240]
   * gen by moon at 9/25/2024, 10:00:40 PM
   */
  @Trace(operationName = "D3转换父子中周期类型（查下级）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementConvertParentSubMidCycleTypeSubContComRespDto implementConvertParentSubMidCycleTypeSubContCom(ImplementConvertParentSubMidCycleTypeSubContComReqDto reqDto){


      ImplementSevenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3接收入参字段  72996
      //ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementSevenReceivingFieldReqDto receptionServiceReq=new ImplementSevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:2010474_1_72996
receptionServiceReq.setCustomField2("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:2010475_1_72996
receptionServiceReq.setCustomField3("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:2010476_1_72996
if(reqDto!=null){
      receptionServiceReq.setCycleMode(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2011132_1_72996
      receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2010473_1_72996
    }

    /*M3接收入参字段[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleMode(),"D3转换父子中周期类型（查下级）(公共)-M3接收入参字段-周期模式不能为空",false);
    Assert.isNull(receptionServiceReq.getParentSubMidCycleType(),"D3转换父子中周期类型（查下级）(公共)-M3接收入参字段-父子中过程周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField1(),"D3转换父子中周期类型（查下级）(公共)-M3接收入参字段-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3转换父子中周期类型（查下级）(公共)-M3接收入参字段-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3转换父子中周期类型（查下级）(公共)-M3接收入参字段-自定义字段3不能为空",false);
      receptionServiceRes = nbEvaCalc.implementSevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))) {
        //if(D3转换父子中周期类型（查下级）(公共).周期模式 等于 父子周期)  72997

if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE"))) {
        //if(D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 父周期)  73017

//ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementSevenReceivingFieldReqDto receptionServiceReq_1=new ImplementSevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2010481_1_73018
    }

    /*M3接收父子中周期类型[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D3转换父子中周期类型（查下级）(公共)-M3接收父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementSevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))){
       //elseif(D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 中期)  73019

//ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementSevenReceivingFieldReqDto receptionServiceReq_2=new ImplementSevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:2010481_1_73020
    }

    /*M3接收父子中周期类型[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D3转换父子中周期类型（查下级）(公共)-M3接收父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementSevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PROCESS_CYCLE"))){
       //elseif((D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 子周期 or D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 过程周期))  73021

//ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementSevenReceivingFieldReqDto receptionServiceReq_3=new ImplementSevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2010481_1_73022
    }

    /*M3接收父子中周期类型[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(),"D3转换父子中周期类型（查下级）(公共)-M3接收父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementSevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
      }
else if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("IRREGULAR_CYCLE"))){
       //elseif((D3转换父子中周期类型（查下级）(公共).周期模式 等于 单周期 or D3转换父子中周期类型（查下级）(公共).周期模式 等于 不规则周期))  73016

if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE")||reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PROCESS_CYCLE"))) {
        //if((D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 父周期 or D3转换父子中周期类型（查下级）(公共).父子中过程周期类型 等于 过程周期))  73025

//ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementSevenReceivingFieldReqDto receptionServiceReq_4=new ImplementSevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2010481_1_73026
    }

    /*M3接收父子中周期类型[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(),"D3转换父子中周期类型（查下级）(公共)-M3接收父子中周期类型-父子中过程周期类型不能为空",false);
      receptionServiceRes_6 = nbEvaCalc.implementSevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
      }
    }
ImplementConvertParentSubMidCycleTypeSubContComRespDto retData = new ImplementConvertParentSubMidCycleTypeSubContComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2010483_1
    }




return retData;
  }
/**
   * D3查询目标内容周期导航列表[10242]
   * gen by moon at 9/27/2024, 1:55:57 PM
   */
  @Trace(operationName = "D3查询目标内容周期导航列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContCyclePhaseMenuListRespDto queryTargetContCyclePhaseMenuList(QueryTargetContCyclePhaseMenuListReqDto reqDto){


      OmsCycle omsCycle_1 =null;
ImplementAllCycleAnalyseParentSubMidCycleTypeComRespDto implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1 =null;
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
List<OmsCycle> listOmsCycle_1 =new ArrayList<>();
//virtualUsage 3-4-04查询周期详情  73008
      OmsCycle omsCycle = null;
    QueryCycleDetailReq queryCycleDetailReq=new QueryCycleDetailReq();
  queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2010770_1_73008
if(reqDto!=null){
      queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2010769_1_73008
    }

    /*3-4-04查询周期详情[2004]   */
    Assert.isNull(queryCycleDetailReq.getCycleId(),"D3查询目标内容周期导航列表-3-4-04查询周期详情-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(),"D3查询目标内容周期导航列表-3-4-04查询周期详情-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsCycle_1 = omsCycle;
//virtualUsage D3父子中单字段转全字段（将空字段赋值为FALSE）  73009
      ImplementAllCycleAnalyseParentSubMidCycleTypeComRespDto implementAllCycleAnalyseParentSubMidCycleTypeComRespDto = null;
    ImplementAllCycleAnalyseParentSubMidCycleTypeComReqDto implementAllCycleAnalyseParentSubMidCycleTypeComReqDto=new ImplementAllCycleAnalyseParentSubMidCycleTypeComReqDto();
  if(reqDto!=null){
      implementAllCycleAnalyseParentSubMidCycleTypeComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2010776_1_73009
implementAllCycleAnalyseParentSubMidCycleTypeComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:2010777_1_73009
implementAllCycleAnalyseParentSubMidCycleTypeComReqDto.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:2010778_1_73009
    }

    /*D3父子中单字段转全字段（将空字段赋值为FALSE）[6318]   */

      implementAllCycleAnalyseParentSubMidCycleTypeComRespDto = targetContentService.implementAllCycleAnalyseParentSubMidCycleTypeCom(implementAllCycleAnalyseParentSubMidCycleTypeComReqDto)/*vcase invoke isSameApp*/;


      implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1 = implementAllCycleAnalyseParentSubMidCycleTypeComRespDto;
if((implementAllCycleAnalyseParentSubMidCycleTypeComRespDto!= null&&  implementAllCycleAnalyseParentSubMidCycleTypeComRespDto.getIsSubCycle() !=null && implementAllCycleAnalyseParentSubMidCycleTypeComRespDto.getIsSubCycle().equals("TRUE")||reqDto!= null&&  reqDto.getWorkCycleIsSame() !=null && reqDto.getWorkCycleIsSame().equals("TRUE"))) {
        //if((D3父子中单字段转全字段（将空字段赋值为FALSE）.是否子周期 等于 是 or D3查询目标内容周期导航列表.工作周期是否同体（父子） 等于 是))  73010

OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    QueryTargetAttributionCycleDetailReq queryTargetAttributionCycleDetailReq=new QueryTargetAttributionCycleDetailReq();
  queryTargetAttributionCycleDetailReq.setParentSubMidCycleType("SUB_CYCLE");//sourceId:2010821_1_73011
queryTargetAttributionCycleDetailReq.setIsWorkCycleData("TRUE");//sourceId:2010822_1_73011
if(reqDto!=null){
      queryTargetAttributionCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2010820_1_73011
queryTargetAttributionCycleDetailReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2010823_1_73011
queryTargetAttributionCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2010819_1_73011
queryTargetAttributionCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2010824_1_73011
    }

    /*3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）[10228]   */
    Assert.isNull(queryTargetAttributionCycleDetailReq.getCycleId(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-归属周期ID不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailReq.getParentSubMidCycleType(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailReq.getIsWorkCycleData(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-是否工作周期数据不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailReq.getBelongToContentId(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailReq.getEvaObjEntityId(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailReq.getSpaceId(),"D3查询目标内容周期导航列表-3-3-07通过工作周期ID结合子周期查询目标归属子周期（把父过滤掉）-创建于空间ID不能为空",false);
      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetAttributionCycleDetail(queryTargetAttributionCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsTargetAttributionCycle> listOmsTargetAttributionCycle =new ArrayList<>();
    if(omsCycle !=null&&omsTargetAttributionCycle !=null){
          QueryTargetBelongCycleByTimeRangeListReq queryTargetBelongCycleByTimeRangeListReq=new QueryTargetBelongCycleByTimeRangeListReq();
  queryTargetBelongCycleByTimeRangeListReq.setIsWorkCycleData("FALSE");//sourceId:2010830_1_73012
queryTargetBelongCycleByTimeRangeListReq.setParentSubMidCycleType("PROCESS_CYCLE");//sourceId:2010831_1_73012
if(omsCycle!=null){
      queryTargetBelongCycleByTimeRangeListReq.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:2010828_1_73012
queryTargetBelongCycleByTimeRangeListReq.setCycleEndTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:2010829_1_73012
    }
if(omsTargetAttributionCycle!=null){
      queryTargetBelongCycleByTimeRangeListReq.setEntityId(omsTargetAttributionCycle.getEntityId());//SimpleFieldAssign//sourceId:2010832_1_73012
    }
if(reqDto!=null){
      queryTargetBelongCycleByTimeRangeListReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2010782_1_73012
queryTargetBelongCycleByTimeRangeListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2010790_1_73012
queryTargetBelongCycleByTimeRangeListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2010783_1_73012
    }

    /*3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间[8580]   */
    Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getCycleStartTime(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getCycleEndTime(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-周期结束时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getIsWorkCycleData(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-是否工作周期数据不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getParentSubMidCycleType(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getEntityId(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getBelongToContentId(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getEvaObjEntityId(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByTimeRangeListReq.getSpaceId(),"D3查询目标内容周期导航列表-3-3-09-07查询目标归属周期列表by大于等于开始时间且小于等于结束时间-创建于空间ID不能为空",false);
      listOmsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleByTimeRangeList(queryTargetBelongCycleByTimeRangeListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    if(listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&& listOmsTargetAttributionCycle.size()>0 &&omsTargetAttributionCycle !=null){
          BatchQueryExecuteCycleStageReq batchQueryExecuteCycleStageReq=new BatchQueryExecuteCycleStageReq();
  batchQueryExecuteCycleStageReq.setRelateContentTypeCode("TARGET");//sourceId:2011252_1_73035
batchQueryExecuteCycleStageReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2011254_1_73035
if(listOmsTargetAttributionCycle!= null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)&&  listOmsTargetAttributionCycle !=null&& !CollectionUtil.isEmpty(listOmsTargetAttributionCycle)){
      batchQueryExecuteCycleStageReq.setExecuteCycleStageList(listOmsTargetAttributionCycle.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2011251_1_73035
    }
if(omsTargetAttributionCycle!=null){
      batchQueryExecuteCycleStageReq.setEvaluationTemplateId(omsTargetAttributionCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2011253_1_73035
    }

    /*3-3-07批量查询执行周期阶段by周期ID[3149]   */
    Assert.isNull(batchQueryExecuteCycleStageReq.getEvaluationTemplateId(),"D3查询目标内容周期导航列表-3-3-07批量查询执行周期阶段by周期ID-评价模板ID不能为空",false);
Assert.isNull(batchQueryExecuteCycleStageReq.getRelateContentTypeCode(),"D3查询目标内容周期导航列表-3-3-07批量查询执行周期阶段by周期ID-关联目标内容类型编码不能为空",false);
Assert.isNull(batchQueryExecuteCycleStageReq.getSubjectLifeCycle(),"D3查询目标内容周期导航列表-3-3-07批量查询执行周期阶段by周期ID-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleStage(batchQueryExecuteCycleStageReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;
           }
List<OmsCycle> listOmsCycle =new ArrayList<>();
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          BatchQueryCycleReq batchQueryCycleReq=new BatchQueryCycleReq();
  batchQueryCycleReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2010835_1_73036
if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      batchQueryCycleReq.setCycleList(listOmsExecuteCycleStage.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2010833_1_73036
    }

    /*3-4-04批量查周期列表[2249]   */
    Assert.isNull(batchQueryCycleReq.getSubjectLifeCycle(),"D3查询目标内容周期导航列表-3-4-04批量查周期列表-主体生命周期不能为空",false);
      listOmsCycle = mOmsCycleService.batchQueryCycle(batchQueryCycleReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsCycle_1 = listOmsCycle;
           }
      }
QueryTargetContCyclePhaseMenuListRespDto retData = new QueryTargetContCyclePhaseMenuListRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsExecuteCycleStage_1!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1) && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1) ){
          for (OmsExecuteCycleStage omsExecuteCycleStage : listOmsExecuteCycleStage_1) {
              ExecuteCycleStageDto retElm = new ExecuteCycleStageDto();
             retElm.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:421050_2
retElm.setCycleStandardName(omsExecuteCycleStage.getCycleStandardName());//SimpleFieldAssign//sourceId:421051_2
retElm.setCycleStartTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:421052_2
retElm.setCycleEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:421053_2
retElm.setCycleTypeCode(omsExecuteCycleStage.getCycleTypeCode());//SimpleFieldAssign//sourceId:421054_2
retElm.setCycleTypeInstanceCode(omsExecuteCycleStage.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:421055_2
retElm.setIsCurrentCycle(omsExecuteCycleStage.getIsCurrentCycle());//SimpleFieldAssign//sourceId:421099_2
retElm.setIsParentCycle(omsExecuteCycleStage.getIsFatherCycle());//SimpleFieldAssign//sourceId:421056_2
retElm.setIsMetaphase(omsExecuteCycleStage.getIsMetaphase());//SimpleFieldAssign//sourceId:421057_2
retElm.setIsSubCycle(omsExecuteCycleStage.getIsSubCycle());//SimpleFieldAssign//sourceId:421058_2
              retData.getExecuteCycleStageList().add(retElm);
               if(listOmsCycle_1!= null&& !CollectionUtil.isEmpty(listOmsCycle_1)){
                   // TODO: 2024/9/27
          for (OmsCycle omsCycle_2 : listOmsCycle_1) {
                if (omsCycle_2.getCycleId().equals(omsExecuteCycleStage.getCycleId())) {
                 retElm.setCycleNumberShortName(omsCycle_2.getCycleNumberShortName());//SimpleFieldAssign//sourceId:421059_2
                }
            }
          }

          }
        }//sourceId:2011257_1
  if(omsCycle_1!=null){
      retData.setCycleId(omsCycle_1.getCycleId());//SimpleFieldAssign//sourceId:2011033_1
retData.setCycleStandardName(omsCycle_1.getCycleStandardName());//SimpleFieldAssign//sourceId:2011034_1
retData.setCycleStartTime(omsCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2011035_1
retData.setCycleEndTime(omsCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:2011036_1
    }
if(implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1!=null){
      retData.setIsParentCycle(implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1.getIsParentCycle());//SimpleFieldAssign//sourceId:2011037_1
retData.setIsMetaphase(implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1.getIsMetaphase());//SimpleFieldAssign//sourceId:2011038_1
retData.setIsSubCycle(implementAllCycleAnalyseParentSubMidCycleTypeComRespDto_1.getIsSubCycle());//SimpleFieldAssign//sourceId:2011039_1
    }




return retData;
  }
/**
   * D3分析非末级周期的最近可循环周期ID(公共)[10258]
   * gen by moon at 10/10/2024, 6:27:46 PM
   */
  @Trace(operationName = "D3分析非末级周期的最近可循环周期ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisNonFinalNextCycleIdComRespDto analysisNonFinalNextCycleIdCom(AnalysisNonFinalNextCycleIdComReqDto reqDto){


      ImplementEightReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage 3-3-11查周期阶段资料详情  73162
      OmsTspeCycleStageData omsTspeCycleStageData = null;
    QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  queryCycleStageDataDetailReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:2017318_1_73162
queryCycleStageDataDetailReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:2017319_1_73162
queryCycleStageDataDetailReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:2017320_1_73162
queryCycleStageDataDetailReq.setIsPlanReceptionCycle("FALSE");//sourceId:2017322_1_73162
queryCycleStageDataDetailReq.setIsActualReceptionCycle("TRUE");//sourceId:2017323_1_73162
queryCycleStageDataDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2017327_1_73162
if(reqDto!=null){
      queryCycleStageDataDetailReq.setCycleDataObjId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2017321_1_73162
queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2017326_1_73162
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getStageContentType(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-内容性质类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataTypeCode(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjTypeCode(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-周期资料归属对象类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getIsPlanReceptionCycle(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-是否计划验收周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getIsActualReceptionCycle(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-是否实际验收周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getSubjectLifeCycle(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-主体生命周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjId(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3分析非末级周期的最近可循环周期ID(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTspeCycleStageData != null )) {
        //if(3-3-11查是否存在提前验收的周期阶段资料.出参 值不等于空 )  73163

//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    if(omsTspeCycleStageData !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(omsTspeCycleStageData!=null){
      receptionServiceReq.setRecentlyNewCycleId(omsTspeCycleStageData.getCycleId());//SimpleFieldAssign//sourceId:2017315_1_73164
    }

    /*M3-接收出参：最近可循环周期ID[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getRecentlyNewCycleId(),"D3分析非末级周期的最近可循环周期ID(公共)-M3-接收出参：最近可循环周期ID-最近可循环最新周期ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementEightReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((omsTspeCycleStageData == null &&reqDto!= null&& reqDto.getRecentlyNewCycleId() != null )){
       //elseif((3-3-11查是否存在提前验收的周期阶段资料.出参 值等于空  and D3分析非末级周期的最近可循环周期ID(公共).最近可循环最新周期ID 值不等于空 ))  73165

//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setRecentlyNewCycleId(reqDto.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:2017315_1_73166
    }

    /*M3-接收出参：最近可循环周期ID[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getRecentlyNewCycleId(),"D3分析非末级周期的最近可循环周期ID(公共)-M3-接收出参：最近可循环周期ID-最近可循环最新周期ID不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementEightReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
AnalysisNonFinalNextCycleIdComRespDto retData = new AnalysisNonFinalNextCycleIdComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setRecentlyNewCycleId(receptionServiceRes_1.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:2017331_1
    }




return retData;
  }
/**
   * D3分析数据计算正常场景中的正常与异常(公共)[10284]
   * gen by moon at 10/27/2024, 12:36:06 AM
   */
  @Trace(operationName = "D3分析数据计算正常场景中的正常与异常(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneCom(AnalysisDataCalcNormalAmSceneComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("NORMAL_SCENE")||reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("ABNORMAL_SCENE"))) {
        //if((D3分析数据计算正常场景中的正常与异常(公共).数据计算正常与异常场景 等于 正常场景 or D3分析数据计算正常场景中的正常与异常(公共).数据计算正常与异常场景 等于 异常场景))  73336

      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("NORMAL_SCENE");//CUSTOM_CONVENTION//sourceId:2024117_1_73339
receptionServiceReq.setCustomField2("ABNORMAL_SCENE");//CUSTOM_CONVENTION//sourceId:2024118_1_73339

    /*M3约定：正常场景、异常场景[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析数据计算正常场景中的正常与异常(公共)-M3约定：正常场景、异常场景-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析数据计算正常场景中的正常与异常(公共)-M3约定：正常场景、异常场景-自定义字段2不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setRelateContentTypeCode("TARGET");//sourceId:2023606_1_73340
queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2023608_1_73340
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2023605_1_73340
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2023607_1_73340
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



      OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    if(omsExecuteCycleStage !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setRelateContentTypeCode("TARGET");//sourceId:2023606_1_73341
queryExecuteCycleStageDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2023608_1_73341
if(omsExecuteCycleStage!=null){
      queryExecuteCycleStageDetailReq_1.setLastExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:2023604_1_73341
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2023607_1_73341
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getRelateContentTypeCode(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getSubjectLifeCycle(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsExecuteCycleStage_2 != null )) {
        //if(3-3-07查询下一个执行周期阶段ID（用当前执行周期阶段ID作为上一个执行周期ID查）.出参 值不等于空 )  73342

OmsTspeCycleStageData omsTspeCycleStageData = null;
    if(omsExecuteCycleStage_2 !=null){
          QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  queryCycleStageDataDetailReq.setIsArchive("FALSE");//sourceId:2024114_1_73345
if(omsExecuteCycleStage_2!=null){
      queryCycleStageDataDetailReq.setCycleId(omsExecuteCycleStage_2.getCycleId());//SimpleFieldAssign//sourceId:2024113_1_73345
    }
if(reqDto!=null){
      queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024115_1_73345
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getCycleId(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-11查周期阶段资料详情-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getIsArchive(),"D3分析数据计算正常场景中的正常与异常(公共)-3-3-11查周期阶段资料详情-是否存档不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsTspeCycleStageData != null )) {
        //if(3-3-11查下一个执行周期的周期阶段资料详情.出参 值不等于空 )  73346

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setDataCalcNormalAbnormal(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2023597_1_73348
    }

    /*M3接收出参字段：数据计算正常与异常场景[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getDataCalcNormalAbnormal(),"D3分析数据计算正常场景中的正常与异常(公共)-M3接收出参字段：数据计算正常与异常场景-数据计算正常与异常场景不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((omsTspeCycleStageData == null )){
       //elseif(3-3-11查下一个执行周期的周期阶段资料详情.出参 值等于空 )  73347

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setDataCalcNormalAbnormal(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2023597_1_73349
    }

    /*M3接收出参字段：数据计算正常与异常场景[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getDataCalcNormalAbnormal(),"D3分析数据计算正常场景中的正常与异常(公共)-M3接收出参字段：数据计算正常与异常场景-数据计算正常与异常场景不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
      }
else if((omsExecuteCycleStage_2 == null )){
       //elseif(3-3-07查询下一个执行周期阶段ID（用当前执行周期阶段ID作为上一个执行周期ID查）.出参 值等于空 )  73343

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
    if(receptionServiceRes!=null){
        receptionServiceReq_3.setDataCalcNormalAbnormal(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2023597_1_73349
    }

    /*M3接收出参字段：数据计算正常与异常场景[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getDataCalcNormalAbnormal(),"D3分析数据计算正常场景中的正常与异常(公共)-M3接收出参字段：数据计算正常与异常场景-数据计算正常与异常场景不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
      }
else if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("REVISE_ABNORMAL_SCENE"))){
       //elseif(D3分析数据计算正常场景中的正常与异常(公共).数据计算正常与异常场景 等于 修订异常场景)  73337

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_4=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_4.setDataCalcNormalAbnormal(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2023597_1_73338
    }

    /*M3接收出参字段：数据计算正常与异常场景[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getDataCalcNormalAbnormal(),"D3分析数据计算正常场景中的正常与异常(公共)-M3接收出参字段：数据计算正常与异常场景-数据计算正常与异常场景不能为空",false);
      receptionServiceRes_6 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
AnalysisDataCalcNormalAmSceneComRespDto retData = new AnalysisDataCalcNormalAmSceneComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setDataCalcNormalAbnormal(receptionServiceRes_3.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2024121_1
    }




return retData;
  }
/**
   * D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)[10285]
   * gen by moon at 10/27/2024, 12:36:21 AM
   */
  @Trace(operationName = "D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcAnormalSceneCurAndUpStandardDataComRespDto implementCalcAnormalSceneCurAndUpStandardDataCom(ImplementCalcAnormalSceneCurAndUpStandardDataComReqDto reqDto){


      //virtualUsage D3查询当前父目标归属周期的周期开始时间（用于查询末级周期第一个周期ID）  73350
      QueryTargetAttributionCycleDetailComRespDto queryTargetAttributionCycleDetailComRespDto = null;
    QueryTargetAttributionCycleDetailComReqDto queryTargetAttributionCycleDetailComReqDto=new QueryTargetAttributionCycleDetailComReqDto();
  queryTargetAttributionCycleDetailComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:2024441_1_73350
if(reqDto!=null){
      queryTargetAttributionCycleDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024440_1_73350
queryTargetAttributionCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024484_1_73350
    }

    /*D3查询当前父目标归属周期的周期开始时间（用于查询末级周期第一个周期ID）[10229]   */
    Assert.isNull(queryTargetAttributionCycleDetailComReqDto.getParentSubMidCycleType(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前父目标归属周期的周期开始时间（用于查询末级周期第一个周期ID）-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailComReqDto.getEntityId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前父目标归属周期的周期开始时间（用于查询末级周期第一个周期ID）-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailComReqDto.getEvaluationTemplateId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前父目标归属周期的周期开始时间（用于查询末级周期第一个周期ID）-冗余评价模板ID不能为空",false);
      queryTargetAttributionCycleDetailComRespDto = queryTargetAttributionCycleDetailCom(queryTargetAttributionCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）  73352
      QueryTargetAttributionCycleDetailComRespDto queryTargetAttributionCycleDetailComRespDto_2 = null;
    if(queryTargetAttributionCycleDetailComRespDto !=null){
          QueryTargetAttributionCycleDetailComReqDto queryTargetAttributionCycleDetailComReqDto_1=new QueryTargetAttributionCycleDetailComReqDto();
  queryTargetAttributionCycleDetailComReqDto_1.setIsLastCycle("TRUE");//sourceId:2024472_1_73352
if(queryTargetAttributionCycleDetailComRespDto!=null){
      queryTargetAttributionCycleDetailComReqDto_1.setCycleStartTime(queryTargetAttributionCycleDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2024471_1_73352
    }
if(reqDto!=null){
      queryTargetAttributionCycleDetailComReqDto_1.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024473_1_73352
queryTargetAttributionCycleDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024485_1_73352
    }

    /*D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）[10229]   */
    Assert.isNull(queryTargetAttributionCycleDetailComReqDto_1.getCycleStartTime(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）-周期开始时间不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailComReqDto_1.getIsLastCycle(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）-是否末级周期不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailComReqDto_1.getEntityId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetAttributionCycleDetailComReqDto_1.getEvaluationTemplateId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3查询当前目标归属周期末级周期第一个周期ID（用父的周期开始时间查）-冗余评价模板ID不能为空",false);
      queryTargetAttributionCycleDetailComRespDto_2 = queryTargetAttributionCycleDetailCom(queryTargetAttributionCycleDetailComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D3-3查询周期阶段资料详情(公共)  73353
      QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    if(queryTargetAttributionCycleDetailComRespDto_2 !=null){
          QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  queryCycleStageDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2024478_1_73353
if(queryTargetAttributionCycleDetailComRespDto_2!=null){
      queryCycleStageDataDetailComReqDto.setCycleId(queryTargetAttributionCycleDetailComRespDto_2.getCycleId());//SimpleFieldAssign//sourceId:2024476_1_73353
queryCycleStageDataDetailComReqDto.setParentEvaObjTargetCycleId(queryTargetAttributionCycleDetailComRespDto_2.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2024477_1_73353
    }
if(reqDto!=null){
      queryCycleStageDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024490_1_73353
    }

    /*D3-3查询周期阶段资料详情(公共)[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3-3查询周期阶段资料详情(公共)-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getParentEvaObjTargetCycleId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3-3查询周期阶段资料详情(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getThemeContentId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3-3查询周期阶段资料详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSubjectLifeCycle(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3-3查询周期阶段资料详情(公共)-主体生命周期不能为空",false);
      queryCycleStageDataDetailComRespDto = cycleStageDataService.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto)/*vcase invoke isSameApp*/;



           }
if((queryCycleStageDataDetailComRespDto!= null&& queryCycleStageDataDetailComRespDto.getCycleStageDataId() != null )) {
        //if(D3-3查询当前目标周期的儿子第一个归属周期ID的当前有效的周期阶段资料.周期阶段资料记录ID 值不等于空 )  73354

ImplementExaReportTaskAndCalcCurAndAnceStdDataComRespDto implementExaReportTaskAndCalcCurAndAnceStdDataComRespDto = null;
    if(queryCycleStageDataDetailComRespDto !=null){
          ImplementExaReportTaskAndCalcCurAndAnceStdDataComReqDto implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto=new ImplementExaReportTaskAndCalcCurAndAnceStdDataComReqDto();
  implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setDataCalcNormalAbnormal("REVISE_ABNORMAL_SCENE");//sourceId:2024398_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setStatusBizOptType("AUTO_REPORT_AUTO_EXECUTE");//sourceId:2024356_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setCalcAndRefreshDataType("CALC");//sourceId:2024354_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setApproveCalcScene("PLAN_TARGET_CALC");//sourceId:2024355_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setExamineOptType("APPROVE");//sourceId:2024346_1_73355
if(queryCycleStageDataDetailComRespDto!=null){
      implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setCycleStageDataId(queryCycleStageDataDetailComRespDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:2024348_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setEvaObjTargetCycleId(queryCycleStageDataDetailComRespDto.getCycleDataObjId());//SimpleFieldAssign//sourceId:2024349_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setCycleId(queryCycleStageDataDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:2024350_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setTargetCycleContentId(queryCycleStageDataDetailComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2024351_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setTargetCycleContentTypeCode(queryCycleStageDataDetailComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:2024352_1_73355
implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.setEvaluationTemplateId(queryCycleStageDataDetailComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:2024353_1_73355
    }

    /*D3执行审核汇报任务并计算当前及祖先标准数据(公共)[9734]   */
    Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getDataCalcNormalAbnormal(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-数据计算正常与异常场景不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getStatusBizOptType(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-任务转成功状态业务操作类型不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getCalcAndRefreshDataType(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-计算与刷新财务数据类型不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getApproveCalcScene(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-审核的计算场景不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getExamineOptType(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-审核通过或失败操作类型不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getEvaObjTargetCycleId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getCycleId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-归属周期ID不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getTargetCycleContentId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getTargetCycleContentTypeCode(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto.getEvaluationTemplateId(),"D3执行修订权重或目标值等计算异常场景当前及祖先规划标准数据(公共)-D3执行审核汇报任务并计算当前及祖先标准数据(公共)-冗余评价模板ID不能为空",false);
      implementExaReportTaskAndCalcCurAndAnceStdDataComRespDto = targetCalcService.implementExaReportTaskAndCalcCurAndAnceStdDataCom(implementExaReportTaskAndCalcCurAndAnceStdDataComReqDto)/*vcase invoke isSameApp*/;



           }
      }
ImplementCalcAnormalSceneCurAndUpStandardDataComRespDto retData = new ImplementCalcAnormalSceneCurAndUpStandardDataComRespDto();





return retData;
  }
/**
   * D3分析克隆非末级周期进入条件(公共)[10416]
   * gen by moon at 12/5/2024, 10:24:38 PM
   */
  @Trace(operationName = "D3分析克隆非末级周期进入条件(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisCloneNoLastCycleEnterConditionComRespDto analysisCloneNoLastCycleEnterConditionCom(AnalysisCloneNoLastCycleEnterConditionComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定字段：最近可循环克隆、提前验收克隆、不克隆  73647
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("RECYCLE_CLONE");//CUSTOM_CONVENTION//sourceId:2033281_1_73647
receptionServiceReq.setCustomField2("ACTUAL_CLONE");//CUSTOM_CONVENTION//sourceId:2033282_1_73647
receptionServiceReq.setCustomField3("NO_CLONE");//CUSTOM_CONVENTION//sourceId:2033283_1_73647

    /*M3约定字段：最近可循环克隆、提前验收克隆、不克隆[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析克隆非末级周期进入条件(公共)-M3约定字段：最近可循环克隆、提前验收克隆、不克隆-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析克隆非末级周期进入条件(公共)-M3约定字段：最近可循环克隆、提前验收克隆、不克隆-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3分析克隆非末级周期进入条件(公共)-M3约定字段：最近可循环克隆、提前验收克隆、不克隆-自定义字段3不能为空",false);
      receptionServiceRes = nbEvaCalc.implementElevenReceivingField(receptionServiceReq);



//virtualUsage D3获取目标归属周期(公共)  73638
      ObtainTargetBelongCycleComRespDto obtainTargetBelongCycleComRespDto = null;
    ObtainTargetBelongCycleComReqDto obtainTargetBelongCycleComReqDto=new ObtainTargetBelongCycleComReqDto();
  obtainTargetBelongCycleComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2032260_1_73638
obtainTargetBelongCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2032167_1_73638
if(reqDto!=null){
      obtainTargetBelongCycleComReqDto.setRecentlyNewCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2032729_1_73638
obtainTargetBelongCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2032257_1_73638
obtainTargetBelongCycleComReqDto.setEntityId(reqDto.getOwnEntityId());//SimpleFieldAssign//sourceId:2032262_1_73638
obtainTargetBelongCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2032258_1_73638
    }

    /*D3获取目标归属周期(公共)[8739]   */
    Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjTypeCode(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getRecentlyNewCycleId(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-最近可循环最新周期ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getCycleId(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-归属周期ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEntityId(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaluationTemplateId(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getSpaceId(),"D3分析克隆非末级周期进入条件(公共)-D3获取目标归属周期(公共)-创建于空间ID不能为空",false);
      obtainTargetBelongCycleComRespDto = targetCalcService.obtainTargetBelongCycleCom(obtainTargetBelongCycleComReqDto)/*vcase invoke isSameApp*/;



if((obtainTargetBelongCycleComRespDto!= null&& obtainTargetBelongCycleComRespDto.getTargetAttributionCycleId() == null )) {
        //if(D3获取目标归属周期（更新周期ID作为最近可循环最新ID）.目标归属周期ID 值等于空 )  73639

QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  queryCycleStageDataDetailComReqDto.setIsActualReceptionCycle("TRUE");//sourceId:2032828_1_73642
queryCycleStageDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2032830_1_73642
if(reqDto!=null){
      queryCycleStageDataDetailComReqDto.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2032825_1_73642
queryCycleStageDataDetailComReqDto.setCycleDataObjId(reqDto.getOwnEntityId());//SimpleFieldAssign//sourceId:2032827_1_73642
queryCycleStageDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2032829_1_73642
    }

    /*D3-3查询周期阶段资料详情(公共)[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleId(),"D3分析克隆非末级周期进入条件(公共)-D3-3查询周期阶段资料详情(公共)-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleDataObjId(),"D3分析克隆非末级周期进入条件(公共)-D3-3查询周期阶段资料详情(公共)-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getIsActualReceptionCycle(),"D3分析克隆非末级周期进入条件(公共)-D3-3查询周期阶段资料详情(公共)-是否实际验收周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getThemeContentId(),"D3分析克隆非末级周期进入条件(公共)-D3-3查询周期阶段资料详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSubjectLifeCycle(),"D3分析克隆非末级周期进入条件(公共)-D3-3查询周期阶段资料详情(公共)-主体生命周期不能为空",false);
      queryCycleStageDataDetailComRespDto = cycleStageDataService.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryCycleStageDataDetailComRespDto!= null&& queryCycleStageDataDetailComRespDto.getCycleStageDataId() == null )) {
        //if(D3-3查询当前周期是否实际验收周期公共).周期阶段资料记录ID 值等于空 )  73643

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setCycleCloneType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:2033279_1_73645
    }

    /*M3接收出参字段：非末级周期克隆类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleCloneType(),"D3分析克隆非末级周期进入条件(公共)-M3接收出参字段：非末级周期克隆类型-非末级周期克隆类型不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((queryCycleStageDataDetailComRespDto!= null&& queryCycleStageDataDetailComRespDto.getCycleStageDataId() != null )){
       //elseif(D3-3查询当前周期是否实际验收周期公共).周期阶段资料记录ID 值不等于空 )  73644

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setCycleCloneType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2033279_1_73646
    }

    /*M3接收出参字段：非末级周期克隆类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCycleCloneType(),"D3分析克隆非末级周期进入条件(公共)-M3接收出参字段：非末级周期克隆类型-非末级周期克隆类型不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
      }
else if((obtainTargetBelongCycleComRespDto!= null&& obtainTargetBelongCycleComRespDto.getTargetAttributionCycleId() != null )){
       //elseif(D3获取目标归属周期（更新周期ID作为最近可循环最新ID）.目标归属周期ID 值不等于空 )  73640

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setCycleCloneType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2033279_1_73641
    }

    /*M3接收出参字段：非末级周期克隆类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCycleCloneType(),"D3分析克隆非末级周期进入条件(公共)-M3接收出参字段：非末级周期克隆类型-非末级周期克隆类型不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
AnalysisCloneNoLastCycleEnterConditionComRespDto retData = new AnalysisCloneNoLastCycleEnterConditionComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCycleCloneType(receptionServiceRes_3.getCycleCloneType());//SimpleFieldAssign//sourceId:2033287_1
    }




return retData;
  }
/**
   * D3新增规划目标MQ队列数据(公共)[10491]
   * gen by moon at 3/6/2025, 12:33:15 AM
   */
  @Trace(operationName = "D3新增规划目标MQ队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanTargetMqQueueComRespDto addPlanTargetMqQueueCom(AddPlanTargetMqQueueComReqDto reqDto){


      //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
     AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
    AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto=new AddMessageQueueDataBusComReqDto();
  addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039656_1
addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039658_1
addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039660_1
addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039662_1
addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039664_1
addMessageQueueDataBusComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2039666_1
addMessageQueueDataBusComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2039668_1
addMessageQueueDataBusComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2039670_1
addMessageQueueDataBusComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039672_1
addMessageQueueDataBusComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2039674_1
addMessageQueueDataBusComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2039676_1
addMessageQueueDataBusComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2039678_1
addMessageQueueDataBusComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2039680_1
addMessageQueueDataBusComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039682_1
addMessageQueueDataBusComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039684_1
addMessageQueueDataBusComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2039686_1
addMessageQueueDataBusComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2039688_1
if(reqDto!=null){
      addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039716_1
addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039717_1
addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039657_1
addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039659_1
addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039661_1
addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039663_1
addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039665_1
addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2039667_1
addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2039669_1
addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2039671_1
addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039673_1
addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2039675_1
addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2039677_1
addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2039679_1
addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039681_1
addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039683_1
addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039685_1
addMessageQueueDataBusComReqDto.setCustomFieldValue16(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2039687_1
addMessageQueueDataBusComReqDto.setCustomFieldValue17(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2039689_1
    }

    /*D2新增MQ队列数据(业务原子)[10490]   */
    Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField16(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段16不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue16(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值16不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField17(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段17不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue17(),"D3新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值17不能为空",false);
      addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddPlanTargetMqQueueComRespDto retData = new AddPlanTargetMqQueueComRespDto();





return retData;
  }
/**
   * D3新增规划财务MQ队列数据(公共)[10492]
   * gen by moon at 3/6/2025, 12:33:31 AM
   */
  @Trace(operationName = "D3新增规划财务MQ队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanFinanceMqQueueComRespDto addPlanFinanceMqQueueCom(AddPlanFinanceMqQueueComReqDto reqDto){


      //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
     AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
    AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto=new AddMessageQueueDataBusComReqDto();
  addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039752_1
addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039754_1
addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039756_1
addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039758_1
addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039760_1
addMessageQueueDataBusComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039762_1
addMessageQueueDataBusComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2039764_1
addMessageQueueDataBusComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2039766_1
addMessageQueueDataBusComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2039768_1
addMessageQueueDataBusComReqDto.setCustomField10(CommonFunctionHelper.getSessionUrl());//ACCESS_ADDRESS//sourceId:2039770_1
addMessageQueueDataBusComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2039772_1
addMessageQueueDataBusComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2039774_1
addMessageQueueDataBusComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039776_1
addMessageQueueDataBusComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039778_1
addMessageQueueDataBusComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2039780_1
if(reqDto!=null){
      addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039812_1
addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039813_1
addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039753_1
addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039755_1
addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039757_1
addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039759_1
addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039761_1
addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039763_1
addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getAccountContentCode());//SimpleFieldAssign//sourceId:2039765_1
addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:2039767_1
addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2039769_1
addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039771_1
addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2039773_1
addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2039775_1
addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039777_1
addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039779_1
addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getUnit());//SimpleFieldAssign//sourceId:2039781_1
    }

    /*D2新增MQ队列数据(业务原子)[10490]   */
    Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue9(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(),"D3新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空",false);
      addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddPlanFinanceMqQueueComRespDto retData = new AddPlanFinanceMqQueueComRespDto();





return retData;
  }
/**
   * D3查询规划目标MQ队列数据列表(公共)[10493]
   * gen by moon at 3/6/2025, 12:33:57 AM
   */
  @Trace(operationName = "D3查询规划目标MQ队列数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanTargetMqQueueListComRespDto queryPlanTargetMqQueueListCom(QueryPlanTargetMqQueueListComReqDto reqDto){


      QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 =null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
     QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
    QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto=new QueryMessageQueueDataListComReqDto();
  queryMessageQueueDataListComReqDto.setMqQueueName("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:2040160_1
queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040040_1
queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040041_1
queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040042_1
queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040043_1
queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040044_1
queryMessageQueueDataListComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2040045_1
queryMessageQueueDataListComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2040046_1
queryMessageQueueDataListComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2040047_1
queryMessageQueueDataListComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040048_1
queryMessageQueueDataListComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2040049_1
queryMessageQueueDataListComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2040050_1
queryMessageQueueDataListComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2040051_1
queryMessageQueueDataListComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040052_1
queryMessageQueueDataListComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040053_1
queryMessageQueueDataListComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040054_1
queryMessageQueueDataListComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2040055_1
queryMessageQueueDataListComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2040056_1
if(reqDto!=null){
      queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040161_1
    }

    /*D2查询MQ队列数据列表(业务原子)[10495]   */
    Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField16(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段16不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField17(),"D3查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段17不能为空",false);
      queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

QueryPlanTargetMqQueueListComRespDto retData = new QueryPlanTargetMqQueueListComRespDto();
  if(queryMessageQueueDataListComRespDto_1!=null){
      retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040091_1
retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040092_1
retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040093_1
retData.setFieldDataList(//objList-to-objLists
        queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
      FieldDataDto elm = new FieldDataDto();
      if(item!=null){
      elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431904_2
elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431905_2
elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431906_2
elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431907_2
elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431908_2
elm.setIsLastCycle(item.getCustomField6());//SimpleFieldAssign//sourceId:431909_2
elm.setParentSubMidCycleType(item.getCustomField7());//SimpleFieldAssign//sourceId:431910_2
elm.setEvaObjTargetCycleCode(item.getCustomField8());//SimpleFieldAssign//sourceId:431911_2
elm.setParentEvaObjTargetCycleId(item.getCustomField9());//SimpleFieldAssign//sourceId:431912_2
elm.setBelongToContentId(item.getCustomField10());//SimpleFieldAssign//sourceId:431913_2
elm.setEvaObjEntityId(item.getCustomField11());//SimpleFieldAssign//sourceId:431914_2
elm.setEvaObjTypeCode(item.getCustomField12());//SimpleFieldAssign//sourceId:431915_2
elm.setEvaluationTemplateId(item.getCustomField13());//SimpleFieldAssign//sourceId:431916_2
elm.setEventBatchUpdateCode(item.getCustomField14());//SimpleFieldAssign//sourceId:431917_2
elm.setCalcStartTime(item.getCustomField15());//SimpleFieldAssign//sourceId:431918_2
elm.setTargetScoreUnit(item.getCustomField16());//SimpleFieldAssign//sourceId:431919_2
elm.setDataCalcNormalAbnormal(item.getCustomField17());//SimpleFieldAssign//sourceId:431920_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040094_1
    }




return retData;
  }
/**
   * D3查询规划财务MQ队列数据列表(公共)[10494]
   * gen by moon at 3/6/2025, 12:34:18 AM
   */
  @Trace(operationName = "D3查询规划财务MQ队列数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanFinanceMqQueueListComRespDto queryPlanFinanceMqQueueListCom(QueryPlanFinanceMqQueueListComReqDto reqDto){


      QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 =null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
     QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
    QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto=new QueryMessageQueueDataListComReqDto();
  queryMessageQueueDataListComReqDto.setMqQueueName("FINANCIAL_CALC_MQ_QUEUE");//sourceId:2040157_1
queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040095_1
queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040096_1
queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040097_1
queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040098_1
queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040099_1
queryMessageQueueDataListComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040100_1
queryMessageQueueDataListComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2040101_1
queryMessageQueueDataListComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2040102_1
queryMessageQueueDataListComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2040103_1
queryMessageQueueDataListComReqDto.setCustomField10("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040104_1
queryMessageQueueDataListComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2040105_1
queryMessageQueueDataListComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2040106_1
queryMessageQueueDataListComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040107_1
queryMessageQueueDataListComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040108_1
queryMessageQueueDataListComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2040109_1
if(reqDto!=null){
      queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040158_1
    }

    /*D2查询MQ队列数据列表(业务原子)[10495]   */
    Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(),"D3查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空",false);
      queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

QueryPlanFinanceMqQueueListComRespDto retData = new QueryPlanFinanceMqQueueListComRespDto();
  if(queryMessageQueueDataListComRespDto_1!=null){
      retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040129_1
retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040130_1
retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040131_1
retData.setFieldDataList(//objList-to-objLists
        queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
      FieldDataDto elm = new FieldDataDto();
      if(item!=null){
      elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431964_2
elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431965_2
elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431966_2
elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431967_2
elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431968_2
elm.setEvaObjTargetCycleId(item.getCustomField6());//SimpleFieldAssign//sourceId:431969_2
elm.setAccountContentCode(item.getCustomField7());//SimpleFieldAssign//sourceId:431970_2
elm.setIsOpenFundsArrival(item.getCustomField8());//SimpleFieldAssign//sourceId:431971_2
elm.setCycleMode(item.getCustomField9());//SimpleFieldAssign//sourceId:431972_2
elm.setEvaluationTemplateId(item.getCustomField10());//SimpleFieldAssign//sourceId:431973_2
elm.setOperationInductionId(item.getCustomField11());//SimpleFieldAssign//sourceId:431974_2
elm.setSpaceId(item.getCustomField12());//SimpleFieldAssign//sourceId:431975_2
elm.setEventBatchUpdateCode(item.getCustomField13());//SimpleFieldAssign//sourceId:431976_2
elm.setCalcStartTime(item.getCustomField14());//SimpleFieldAssign//sourceId:431977_2
elm.setUnit(item.getCustomField15());//SimpleFieldAssign//sourceId:431978_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040132_1
    }




return retData;
  }
  //
}
